NativeCAD MCP server

The tool reference

Everything an agent can call on nativecad-mcp 0.27.0: 188 tools, grouped by subsystem, each with the input schema the server actually validates against — argument by argument, required and optional, with units, bounds and defaults.

This page is generated from the running server, not written. The modeling surface is derived (one tool per commands/schema op), so a hand-kept list would describe a product nobody receives. Every name, sentence and schema below is the same JSON a connected model is handed by tools/list, and the conventions and error codes are what cad_server_info reports about itself.

188tools

15subsystems

40read-only

26error codes

Primitives & sketches 15
Features 38
Freeform surfacing 17
Booleans, transforms & patterns 13
Shaft features & turned parts 6
Joinery 2
Datums, parameters & model state 24
Query, measurement & preview 12
GD&T and PMI 4
Assemblies 9
Manufacturing review & simulation 16
Import & export 4
Quoting, evaluation & sharing 12
Printing (Bambu Lab X1 Carbon) 10
Server, config & licence 6

Conventions

There is no unit argument anywhere on this server. A number is millimetres or radians by position, and every tool below inherits these:

Length: millimetre
Angle: radian
Axes: right-handed, +Z up
Profiles: open point lists; outer loops CCW, hole loops CW
Body references: "<opId>" is body 0; "<opId>#<n>" addresses body n of a multi-body result

Profile winding is the single most common failure: a hole loop wound counter-clockwise either removes no material or produces a non-watertight solid, and the refusal you get back talks about watertightness rather than about winding. There is no native circular-hole profile — approximate a circle with a regular N-gon (N = 24–32 keeps the volume error under 1%), sampled clockwise for a hole.

Errors are refusals, and they tell you what to do

A failing call does not throw and does not return prose. It returns one envelope with a code from this closed vocabulary, a hint written for the caller, and recoverable — the honest answer to “is calling me again, with different arguments, worth it?”. A kernel refusal (E_GEOMETRY) is recoverable because a smaller radius often succeeds; an unsupported feature is not, and retrying it just burns turns.

Code	Retry worth it?	What it means, and what to do
`E_ASSEMBLY_UNSOUND`	yes	The exported set is not a sound assembly: a part floats, interpenetrates another, or does not reach the floor. `details.assembly.parts[]` names each one with the measurement. Move or resize the offending part (cad_transform / cad_move_face) and export again — or drop "strict" to export it anyway with the same report attached as a warning.
`E_BODY_IN_USE`	yes	A later op in the same document references this body (or sketch), so removing it would silently remove that op's result as well. Delete the dependents listed in `details.dependents` first, last to first, or leave the body and build a fresh one.
`E_CANCELLED`	yes	This operation was cancelled at the client's request. The kernel worker was terminated to interrupt it and the document was replayed from its op journal, so every body built before the cancelled call is still addressable, and any partially-written output file was removed. Nothing needs repairing; re-issue the call (with a smaller request, if it was cancelled for being slow) when you want it.
`E_CONFLICT`	yes	The request conflicts with the current model state. Re-read the state — it changed since you last looked — and rebuild the request from what is there now.
`E_CONTEST_OFFLINE`	yes	The contest site could not be reached. Nothing was kept on disk and the build is still in this session — check the connection (or CADSOLVER_MCP_CONTEST_ENDPOINT) and call cad_contest submit again.
`E_CONTEST_REJECTED`	yes	The contest site refused the entry; details.status and details.reasons say why. Nothing was kept on disk and the build is still in this session — fix what it names and call cad_contest submit again.
`E_CONTEST_SCOPE`	yes	A contest build can only leave this machine as a contest entry: call cad_contest({action:"submit", title:"…", agree:true}) to enter it, or cad_contest({action:"end"}) to close the scope. To keep your own copy, register free at https://featureboard.ai/register?source=nativecad and activate the key with cad_license.
`E_EVAL_CONSENT_REQUIRED`	yes	This session is unlicensed, so the evaluation runs under an agent-issued evaluation approval (LICENSE §2). Ask the human for their acceptance criteria and their agreement to the consent statement in `details.consentStatement`, then call again with `criteria` and `consent`. Registering a free key at https://featureboard.ai/nativecad/web/pricing.html removes the requirement entirely.
`E_FURNITURE_UNSOUND`	yes	The furniture ruleset raised an error-severity finding: a leg that reaches nothing, a member under its material's thickness floor, or an envelope outside the stated tolerance. `details.furniture.rules[]` names the rule, its band and its basis; each finding names the parts. Fix the geometry (cad_transform / cad_move_face) or correct the stated figures, and review again — or drop "strict" to get the same report as warnings.
`E_GEOMETRY`	yes	The CAD kernel refused the operation. Change the parameters (smaller radius, thicker wall, different edge selection, coarser tolerance) and retry — do not repeat the identical call.
`E_INTERNAL`	no	Unexpected server fault — this is a bug in NativeCAD, not in your request. Report the tool name and arguments; retrying is unlikely to help.
`E_INVALID_ARGS`	yes	The arguments did not match the tool's inputSchema. `details.issues` names the exact JSON path that failed — fix that path and call again.
`E_IO`	yes	A file could not be read or written. Check the path, and that the directory exists and is writable.
`E_KERNEL_CRASHED`	yes	The kernel worker died during this operation and was restarted with the document replayed from its op journal — every body built before this call is still addressable. Retry the call; if it dies again, the op itself is the trigger and is worth reporting.
`E_KERNEL_OOM`	yes	The kernel worker hit its memory ceiling and was restarted; the document survived and was replayed. Retry with a coarser "tolerance" or a smaller "maxTriangles", export fewer bodies at once, or raise CADSOLVER_MCP_KERNEL_WORKER_MAX_OLD_MB if this machine has the headroom.
`E_LICENSE_REQUIRED`	yes	This tool needs a licence key. Register free at https://featureboard.ai/register?source=nativecad, then call cad_license({action:"activate", key:"CSLV1-…"}) and retry. The evaluation loop (cad_evaluate and cad_eval_*) works without a key.
`E_LIMIT`	yes	A budget was exceeded (size, element count, or step count). Reduce the resolution or scope of the request.
`E_MULTI_BODY_HANDLE`	yes	This reference names a SET of bodies (a pattern, a split, a multi-body import) and this argument takes exactly one. Address a single body as "<id>#<n>" (0-based) — `details.choices` lists them — or use an aggregate tool (cad_mass_properties, cad_body_topology, cad_dfm_check, cad_export_body), which read the whole group.
`E_NOT_FOUND`	yes	The referenced id does not exist. List the current model state and use an id from that listing.
`E_PRECONDITION`	yes	The server is not in a state where this tool can run. Perform the missing setup step first, then retry.
`E_STEP_SCHEMA_UNSUPPORTED`	yes	The chosen STEP schema cannot carry part of this export (PMI and tessellation are AP242-only; AP203 ed1 has no colours, layers or validation properties). `details.dropped` / `details.refused` / `details.leaked` name what. Export as schema "ap242e2", or drop strict:true to write without it (the omission is reported).
`E_TIMEOUT`	yes	The operation ran out of time. Retry with a coarser tolerance or a smaller model.
`E_UNKNOWN_TOOL`	yes	Call tools/list and use a name from that listing. Do not guess tool names.
`E_UNSUPPORTED`	no	This build does not support the requested feature. Take a different modelling approach; retrying will not help.
`E_VERSION_EXISTS`	yes	This document already has a version with that name. Pick another name — a version is never overwritten — or cad_restore the existing one if that is what you meant.
`E_VERSION_UNKNOWN`	yes	No version by that id or name. Call cad_versions {document} for the versions this session holds (ids are "v1", "v2", …; names are per document) and use one from that listing. Versions are journal-backed, but cad_session_reset discards them with the documents.

Envelope: { "error": { "code", "message", "hint", "recoverable", "details?", "tool?" } } — delivered as a normal tool result with isError: true; the envelope is also in structuredContent.

The tools

Filter by name or summary
188 tools

The read / write / destructive badge is the server's own readOnlyHint / destructiveHint annotation, not a guess from the name.

Primitives & sketches · 15

The shapes you start from: analytic solids, a planar sheet, and the sketch composer that turns a profile into geometry the rest of the surface can act on.

`cad_box` write Box

Rectangular block, axis-aligned.

Full description

A box of size dx*dy*dz (mm), min-corner at origin (default [0,0,0]). Call cad_help({tool:"cad_box"}) for the rest.

Argument	Type	Meaning & bounds
`dx` required	`number`	— > 0
`dy` required	`number`	— > 0
`dz` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_cylinder` write Cylinder

Right circular cylinder, axis +Z from its base.

Full description

To put a cylinder ON a face of an existing body use cad_pad with a 16–32-gon outer; use cad_cylinder for standalone parts or as a boolean tool on plain faces. Radius r, height h (mm), base centred at origin (default [0,0,0]). Call cad_help({tool:"cad_cylinder"}) for the rest.

Argument	Type	Meaning & bounds
`h` required	`number`	— > 0
`r` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_cone` write Cone

Right circular cone, axis +Z from its base.

Full description

Base radius r, height h (mm), apex on +Z above origin (default [0,0,0]). Call cad_help({tool:"cad_cone"}) for the rest.

Argument	Type	Meaning & bounds
`h` required	`number`	— > 0
`r` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_frustum` write Frustum

Conical frustum (truncated cone), axis +Z from its base.

Full description

Base radius r0, top radius r1, height h (mm); either radius may be smaller than the other. Call cad_help({tool:"cad_frustum"}) for the rest.

Argument	Type	Meaning & bounds
`h` required	`number`	— > 0
`r0` required	`number`	— > 0
`r1` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sphere` write Sphere

Sphere.

Full description

Radius r (mm), centred at origin (default [0,0,0]). Call cad_help({tool:"cad_sphere"}) for the rest.

Argument	Type	Meaning & bounds
`r` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_torus` write Torus

Torus (donut), axis +Z.

Full description

Major radius R (centre of tube to torus axis) and minor radius rmin (tube radius), R > rmin, mm. Call cad_help({tool:"cad_torus"}) for the rest.

Argument	Type	Meaning & bounds
`R` required	`number`	— > 0
`rmin` required	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_polyhedron` write Polyhedron

Regular polyhedron.

Full description

kind selects the solid (tetrahedron/hexahedron/octahedron/dodecahedron/icosahedron/trapezohedron10); R is the circumradius (mm), centred at origin. Call cad_help({tool:"cad_polyhedron"}) for the rest.

Argument	Type	Meaning & bounds
`R` required	`number`	— > 0
`kind` required	`enum`	— one of "tetrahedron", "hexahedron", "octahedron", "dodecahedron", "icosahedron", "trapezohedron10"
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_planar_sheet` write Planar sheet

Build a flat plate as an OPEN SHEET body (not a solid) from a planar profile — the input thicken consumes.

Full description

profile is a CCW, NOT-closed [[u,v],...] loop (mm) in plane's frame — the same convention extrude's outer uses, and the same plane ({origin,xAxis,yAxis} or a datum_plane id) sketch_begin/extrude take. Call cad_help({tool:"cad_planar_sheet"}) for the rest.

Argument	Type	Meaning & bounds
`profile` required	`number[][]`	>=3 [x,y], unclosed ≥ 3 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`plane` optional	`object \| string`	frame or datum id
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_create_sketch` write Create sketch

Draw a closed (or open, for rib) 2D sketch on a plane: lines/arcs/circles/points/polylines, mm and radians.

Full description

Returns a "sketch" handle for cad_extrude_profile's/cad_revolve_profile's {sketch:"<handle>"} profile field. Composes this kernel's sketch_begin+sketch_entity+sketch_end into one call. Call cad_help({tool:"cad_create_sketch"}) for the rest.

Argument	Type	Meaning & bounds
`entities` required	`object[]`	One or more 2D entities, added in order, in thi… ≥ 1 items
`document` optional	`string`	handle or "new" length ≥ 1
`plane` optional	`object \| string`	frame or datum id

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_dice_pips` write Engrave dice pips

Engrave classic 1-6 die pips into a blended cube.

Full description

Retires of. Optional spread/pipRadius/pipDepth override defaults derived from face size. Purpose-built for a d6; for general text engraving use engrave_text. Example: {"op":"dicePips","id":"die","of":"rounded"}

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`pipDepth` optional	`number`	— > 0
`pipRadius` optional	`number`	— > 0
`spread` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_padstack` write Padstack

Build a PCB padstack — plated through hole, back-drill, microvia stack, pads, antipads, fill, cap plating, laminate and mask — as one watertight body PER MATERIAL, sharing its interface faces, with a closed-form volume for every body.

Full description

Call cad_help({tool:"cad_padstack"}) for the rest.

Argument	Type	Meaning & bounds
`stackup` required	`object[]`	— ≥ 1 items · ≤ 64 items
`vias` required	`object[]`	— ≥ 1 items · ≤ 64 items
`cell` optional	`object`	—
`cell.pitch`	`number[]`	— exactly 2 items
`cell.n`	`integer[]`	— exactly 2 items
`cell.periodic`	`boolean`	—
`document` optional	`string`	— length ≥ 1
`keepFailed` optional	`boolean`	—
`laminateExtent` optional	`number[]`	— exactly 2 items
`mask` optional	`object`	—
`mask.thickness`	`number`	— > 0
`mask.material`	`string`	—
`mask.opening`	`number`	— > 0
`mask.sides`	`enum`	— one of "top", "bottom", "both"
`resin` optional	`boolean \| object`	—
`suppressed` optional	`boolean`	—
`voids` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_trace_section` write Trace section

Build a transmission-line cross section — trapezoidal trace(s) from an etch factor or explicit top/bottom widths, foil + plating as two Cu bodies, ground and dielectric slabs, an optional conformal solder mask, and a neat-resin window between a stripline pair — as one watertight body per material/role, extruded alon…

Full description

g a straight… Call cad_help({tool:"cad_trace_section"}) for the rest.

Argument	Type	Meaning & bounds
`conductors` required	`object[]`	1 or 2 conductors… ≥ 1 items · ≤ 2 items
`dielectrics` required	`object`	the dielectric(s) around th…
`dielectrics.below`	`object`	—
`dielectrics.above`	`object`	—
`bandFill` optional	`boolean \| object`	kind "stripline" only: fill…
`document` optional	`string`	handle or "new" length ≥ 1
`ground` optional	`object`	the ground plane…
`ground.gap`	`number`	kind "cpw" only: the cleara…
`ground.thickness`	`number`	the ground plane thickness… > 0
`ground.width`	`number`	the ground plane / dielectr… > 0
`keepFailed` optional	`boolean`	—
`kind` optional	`enum`	"microstrip"… one of "microstrip", "stripline", "cpw", "diffpair"
`length` optional	`number`	— > 0
`mask` optional	`object`	a conformal solder mask ove…
`mask.thickness`	`number`	the conformal solder mask t… > 0
`mask.conformal`	`boolean`	documents the intent; the m…
`mask.corners`	`enum`	the mask's outer corners ov… one of "mitre", "round"
`mask.material`	`string`	default "LPI"
`resinWindow` optional	`object`	the neat-resin region betwe…
`resinWindow.width`	`number`	mm — must equal `spacing`… > 0
`resinWindow.material`	`string`	default "resin"
`route` optional	`object`	a swept route instead of `l…
`sectionOrigin` optional	`number[]`	[x,y,z] mm exactly 3 items
`spacing` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_glass_weave` write Glass Weave

Build the periodic woven-glass unit cell of a PCB laminate — warp and weft yarn bundles, the resin they sit in and an optional Cu trace at an angle — as one tagged B-rep body per yarn / resin / trace that exports to one STEP and meshes.

Full description

Call cad_help({tool:"cad_glass_weave"}) for the rest.

Argument	Type	Meaning & bounds
`cells` optional	`integer[]`	[nWarp, nWeft] — how many… exactly 2 items
`clearance` optional	`number`	mm, >= 0 ≥ 0
`document` optional	`string`	handle or "new" length ≥ 1
`fibreFraction` optional	`number`	the glass fraction inside a… > 0 · ≤ 1
`keepFailed` optional	`boolean`	—
`pattern` optional	`enum`	the interlacing — 'plain'… one of "plain"
`resin` optional	`object \| string`	the resin the glass sits in
`section` optional	`enum`	the yarn bundle's section… one of "lenticular", "ellipse"
`sectionNodes` optional	`integer`	segments per arc of the yar… ≥ 4 · ≤ 64
`spread` optional	`boolean`	—
`spreadFactor` optional	`number`	— > 0
`stationsPerPitch` optional	`integer`	path stations per pitch of… ≥ 4 · ≤ 128
`style` optional	`object \| string`	the glass fabric.
`suppressed` optional	`boolean`	true = not built
`trace` optional	`boolean \| object`	a copper trace lying ON the…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_gear` write Gear

Build an involute gear: external or internal, spur, helical or herringbone, or a straight or spiral bevel, with print-in-place backlash cut into the teeth.

Full description

Call cad_help({tool:"cad_gear"}) for the rest.

Argument	Type	Meaning & bounds
`addendumCoefficient` optional	`number`	— > 0
`allowUndercut` optional	`boolean`	—
`backlashPerFlank` optional	`number`	—
`bore` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`faceWidth` optional	`number`	— > 0
`hand` optional	`enum`	helix hand; an external pair needs OPPOSITE han… one of "right", "left"
`helixDeg` optional	`number`	—
`herringbone` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`kind` optional	`enum`	external, internal (ring gear), bevel… one of "external", "internal", "bevel", "spiral_bevel", "hypoid"
`mateTeeth` optional	`integer`	— ≥ 1
`module` optional	`number`	— > 0
`offset` optional	`number`	—
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`pressureAngleDeg` optional	`number`	— > 0
`process` optional	`string`	process name for the minimum-module gate…
`profileShift` optional	`number`	—
`rimWidth` optional	`number`	— > 0
`rootFillet` optional	`number`	—
`sagitta` optional	`number`	— > 0
`sections` optional	`integer`	— ≥ 1
`shaftAngleDeg` optional	`number`	— > 0
`spiralAngleDeg` optional	`number`	—
`suppressed` optional	`boolean`	true = not built
`teeth` optional	`integer`	— ≥ 1
`tipClearance` optional	`number`	—
`tipRelief` optional	`object`	tip relief: the outer band of each flank shaved…
`tipRelief.depth`	`number`	mm removed at the tip > 0
`tipRelief.height`	`number`	mm of radial ramp below the tip… > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sketch_solve` write Solve a constrained 2D sketch

Solve a constrained 2D sketch (rough entities, or a cad_create_sketch handle as sketch) plus constraints: exact coordinates, DOF left and, if unsolvable, fewest constraints to delete.

Full description

Refs: an entity id or a point on it (L1.p0, L1.p1, L1.mid, A1.start, A1.end, C1.center); dimensions take a value (mm, rad) or driven:true to measure. Call cad_help({tool:"cad_sketch_solve"}) for the rest.

Argument	Type	Meaning & bounds
`constrain` optional	`object[]`	With sketch: constraints (same shape as constraints) ADDED to the ones stored on it — stored only if the sketch still solves; an id already stored replaces that constraint. ≤ 256 items
`constraints` optional	`object[]`	What must hold. Each names its entities by ref; dimensions carry a value (mm, or radians for angle) unless driven:true. An empty list is legal (reports the free DOF). With sketch: for this call only, never stored. ≤ 256 items
`drag` optional	`object`	Move the SOLVED sketch: pull one point toward a target. Everything else moves as little as the constraints allow; dof is unchanged. The reply adds drag {point, achieved, residual}.
`drag.point`	`string`	The point to drag: a point id or a point ref (L1.p1, L1.mid, A1.start, C1.center). length ≥ 1
`drag.to`	`number[]`	Target [x, y], mm. Out of reach: the point stops as close as the constraints allow. exactly 2 items
`drag.keepBranch`	`boolean`	When the drag would flip a tangent / perpendicular / side to its other branch: stay on the starting branch and stop short (drag.residual > 0, a warning names the constraint) instead of returning the flipped sketch. Default false.
`drag.pins`	`string[]`	Point refs to hold exactly where the solved sketch has them during the drag. ≤ 64 items
`entities` optional	`object[]`	The sketch geometry in plane coordinates (mm), where you roughly want it — the solve moves it. point {p}, line {p0, p1}, circle {center, r}, arc {center, r, a0, a1} (radians, swept CCW a0 to a1). ≥ 1 items · ≤ 128 items
`options` optional	`object`	—
`options.acceptTol`	`number`	Residual norm that counts as solved (default 1e-7). > 0 · ≤ 0.001
`options.maxIter`	`integer`	Levenberg-Marquardt iteration cap (default 100). ≥ 1 · ≤ 1000
`sketch` optional	`string`	A cad_create_sketch "sketch" handle, instead of entities: solve the sketch in the document. Its entities are e1, e2, … in drawing order (a polyline eN as its segments eN_1, eN_2, …); corners it joins are held (_j1, _j2, …). length ≥ 1
`unconstrain` optional	`string[]`	With sketch: ids of STORED constraints to delete (applied before constrain). An id that is not stored is refused; the deletion is stored only if the sketch still solves. ≤ 256 items
`write` optional	`boolean`	With sketch: write the solved coordinates into the document and rebuild everything that uses the sketch (waits for a write in flight). Default false: read-only.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Returns no structured fields.

Exactly one of these argument shapes: status + dof + freeEntities + conflictSet + redundant + entities + dimensions + iterations + residual + geometryApplied + conflictSearch + warnings + units — or — spillPath + bytes + budgetBytes — or — error.

Features · 38

Everything that adds or removes material from an existing body - the verbs a machinist or a moulder would recognise, each one leaving a watertight solid behind.

`cad_pad` write Pad

Extrude a profile that lies ON a face and merge it into that solid (boss or, with negative length, pocket) — one body, no boolean needed.

Full description

Retires of, publishes ONE merged body under this op's id. Call cad_help({tool:"cad_pad"}) for the rest.

Argument	Type	Meaning & bounds
`face` required	`object \| string`	a face selector: raw STEP id \| { normal:[x,y,z] } \| { normal:[x,y,z], through:[x,y,z] } \| { surface:"cylinder" } \| { ref:"<provenance tag>" }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`extent` optional	`object`	END CONDITION (CADSF-101462): a pad up to a face. Symmetric / two-sided / through-all / tapered features are extrude with operation join or cut (PAD_EXTENT_NEEDS_EXTRUDE)
`extent.body`	`string`	up_to_body: the body to pad up to; up_to_face: the body `face` is on (default `of`) length ≥ 1
`extent.face`	`object \| string`	up_to_face: the end face (planar, parallel to the host face)
`extent.flip`	`boolean`	up_to_next / up_to_body: look INTO the material (a pocket)
`extent.offset`	`number`	up_to_*: mm past the face (+) or short of it (-)
`extent.type`	`enum`	blind (`length`) \| up_to_next \| up_to_face \| up_to_body — resolved to ONE signed length along the face normal one of "blind", "up_to_next", "up_to_face", "up_to_body"
`flush` optional	`boolean`	—
`flushTol` optional	`number`	— > 0
`keepFailed` optional	`boolean`	—
`length` optional	`number`	a signed number (must not be exactly 0) — a signed field where a negative value is meaningful (a pad with a negative length cuts a pocket) rather than an error; extrude depth (extrudeDepth) is the other
`outer` optional	`array \| object`	one closed loop: [[x,y],...] points, one {circle}/{slot}/{rect} primitive, or a {start,segments} line/arc loop (winding then inferred by containment)
`profile` optional	`object`	the pad/pocket footprint: { sketch: "<id>" } (read in the sketch's plane) or { outer } (read in the host face's plane)
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

Exactly one of these argument shapes: outer — or — profile. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_extrude_profile` write Extrude profile

Extrude a closed 2D profile into a prism (a straight prism in free space — use pad instead when the profile lies ON an existing face).

Full description

End conditions, taper and join/cut/intersect: extent + operation + of. Call cad_help({tool:"cad_extrude_profile"}) for the rest.

Argument	Type	Meaning & bounds
`depth` optional	`number`	extrude depth in mm, signed: positive sweeps along the profile plane's normal, negative the other way (must not be exactly 0)
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`extent` optional	`object`	END CONDITION (CADSF-101462) — blind (default: `depth`, signed) \| symmetric (`depth` = TOTAL length, half each side) \| two_sides (side 1 `depth`, side 2 `depth2` the other way) \| through_all (past every body ahead) \| up_to_next (first parallel planar face the profile meets) \| up_to_face (`face`) \| up_to_body (`body`); plus taper / taper2 and up_to_* `offset`. Refusals are coded: EXTRUDE_UPTO_FACE_NOT_REACHED, EXTRUDE_UPTO_FACE_NOT_PARALLEL, EXTRUDE_TAPER_COLLAPSE, ... (entry.extent reports t0/t1)
`extent.body`	`string`	up_to_body: the body to extrude up to; up_to_face: the body `face` is on length ≥ 1
`extent.depth2`	`number`	two_sides: the second side's length (mm), opposite to `depth` > 0
`extent.face`	`object \| string`	up_to_face: the end face (planar, parallel to the sketch plane), on `body` (or `of`)
`extent.flip`	`boolean`	through_all / up_to_next / up_to_body: run against the plane normal
`extent.offset`	`number`	up_to_*: mm past the face (+) or short of it (-)
`extent.taper`	`number`	draft angle (radians, \|a\| < pi/2) of side 1 — positive shrinks the profile away from the sketch plane; walls stay exact (planes, cones)
`extent.taper2`	`number`	two_sides / symmetric: side 2's draft angle (symmetric defaults to `taper`)
`extent.type`	`enum`	blind (default: `depth`, signed) \| symmetric (`depth` = TOTAL length, half each side) \| two_sides (side 1 `depth`, side 2 `depth2` the other way) \| through_all (past every body ahead) \| up_to_next (first parallel planar face the profile meets) \| up_to_face (`face`) \| up_to_body (`body`) one of "blind", "symmetric", "two_sides", "through_all", "up_to_next", "up_to_face", "up_to_body"
`holes` optional	`array \| object[]`	hole loops: each is [[x,y],...] (CW), one {circle}/{slot}/{rect} primitive or a {start,segments} line/arc loop (winding inferred)
`keepFailed` optional	`boolean`	—
`of` optional	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`operation` optional	`enum`	new (default: a separate body) \| join \| cut \| intersect — combined with `of` by the same boolean as cad_boolean_union / subtract / intersect, under this op's id one of "new", "join", "cut", "intersect"
`orient` optional	`boolean`	—
`outer` optional	`array \| object`	one closed loop: [[x,y],...] points, one {circle}/{slot}/{rect} primitive, or a {start,segments} line/arc loop (winding then inferred by containment)
`plane` optional	`object \| string`	a sketch/inline-profile plane: either an explicit frame object or the id string of an earlier datum_plane
`profile` optional	`object`	the closed profile to extrude: { sketch: "<id>" } or { outer, holes? } (mm). Each loop is [[x,y],...] (outer CCW, holes CW) OR one native primitive — {circle:{cx,cy,r}} (d/diameter accepted for r) \| {slot:{x1,y1,x2,y2,width}} (the two END-ARC CENTRES; end radius = width/2) or {slot:{cx,cy,length,width,angle}} (length is OVERALL tip-to-tip, >= width; angle in RADIANS) \| {rect:{x,y,w,h,cornerRadius}} (x,y is the CENTRE) — OR a free-form line/arc loop {start:[x,y], segments:[{to} \| {to,center,ccw}]} (CADSF-2606; arcs exact, winding inferred)
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

Exactly one of these argument shapes: outer — or — profile. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_revolve_profile` write Revolve profile

Revolve a 2D profile about the Z axis (shafts, bosses, hubs, pulleys, flanges).

Full description

A native primitive is accepted as the silhouette: {"circle":{"cx","cy","r"}} in the r-z half-plane sweeps an EXACT TORUS (needs cx > r), and {"slot"}/{"rect"} give a rounded / plain ring. Call cad_help({tool:"cad_revolve_profile"}) for the rest.

Argument	Type	Meaning & bounds
`profile` required	`array \| object`	the profile to revolve abou…
`angle` optional	`number`	sweep angle in RADIANS, (0… > 0 · ≤ 6.283185308179586
`arcs` optional	`object[]`	marks profile segments as c… ≥ 1 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`orient` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sweep_profile` write Sweep profile along a path

Sweep a closed section along an analytic path — rigid, or scaling/twisting/following guide curves.

Full description

The section is a closed loop of LINE and ARC segments drawn in its own 2-D (a,b) frame, with the path running through (a,b)=(0,0) and +b along the path plane's normal. Call cad_help({tool:"cad_sweep_profile"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`object`	the analytic path: a coplanar polyline with corner fillets, or explicit line/arc legs. Straight and circular-arc legs only — there is no B-spline path in this kernel.
`section` required	`object`	a closed line/arc loop drawn CCW in the section's own (a,b) frame, in millimetres
`section.segments`	`object[]`	segments in order; the last one must close back onto `start`. Two suffice when the loop curves (a circle is two semicircles); three otherwise. ≥ 2 items
`section.start`	`number[]`	the loop's first point [a,b] (mm) in the section frame exactly 2 items
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`guideMode` optional	`enum`	which half of the guides' similarity fit to apply: "both" (scale + rotation, the default), "scale" (size only — the section keeps its orientation), "twist" (rotation only — the section keeps its size), or "none" (guides are measured and reported but do not move the section). one of "both", "scale", "twist", "none"
`guides` optional	`number[][][]`	guide curves: 3D polylines [[x,y,z],...] the section follows. Each guide must be OFFSET from the path and must cross every section plane along it. At each station the least-squares similarity (uniform scale + rotation) carrying every guide's starting offset onto its current one is applied to the section, so ONE guide makes the surface pass exactly through it and several split the difference. Anchor a guide ON the section's outline at the start if you want the finished face to contain it. ≥ 1 items
`holes` optional	`object[]`	inner loops subtracted from the section — a swept TUBE (bent pipe). Wind each one the opposite way from the outer section. ≥ 1 items
`keepFailed` optional	`boolean`	—
`maxBandAngle` optional	`number`	— > 0
`scale` optional	`number \| object \| string`	variable profile: how the section's SIZE changes along the path. A number scales it uniformly; a law s(t) varies it with normalised arc length; { a, b } scales the section's two axes independently. Must stay strictly positive — 0 collapses the section onto the path and negative turns it inside out, both refused.
`sectionTolerance` optional	`number`	— > 0
`stations` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`twist` optional	`number \| string`	twist: rotation of the section about the path tangent, in RADIANS. Positive is CCW seen looking along the direction of travel.
`up` optional	`number[]`	[x, y, z] in millimetres exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_tube_sweep` write Tube sweep

Sweep a closed section along a NON-PLANAR 3-D path (helix, 3-D polyline, B-spline) — coil spring, wound tube, routed pipe.

Full description

Use it, not sweep, once the path leaves a plane: sweep fits ONE plane through its path and refuses the first point off it (reasonCode "sweep_path_not_planar"), and has no helix. Call cad_help({tool:"cad_tube_sweep"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`object`	the 3-D path: { helix: { radius, pitch, turns, hand } }, { points: [[x,y,z], ...] } (a 3-D polyline, coplanarity NOT required) or { bspline: { ctrl, degree, samples } }. A PLANAR line/arc path belongs to `sweep`, which builds it exactly; this op is the non-planar one.
`section` required	`object`	a closed line/arc loop drawn CCW in the section's own (a,b) frame, in millimetres
`section.segments`	`object[]`	segments in order; the last one must close back onto `start`. Two suffice when the loop curves (a circle is two semicircles); three otherwise. ≥ 2 items
`section.start`	`number[]`	the loop's first point [a,b] (mm) in the section frame exactly 2 items
`bandStations` optional	`integer \| string`	stations per B-spline skin band: an integer >= 1 (default 9), or "auto" for the longest bands that keep each merged wall face merged (fewer faces and entities; the display mesh grows by a bounded factor, analytic.bandPlan says what was chosen). Band length moves the exact volume of a B-spline path by ~1e-5 relative.
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`exactSection` optional	`boolean`	—
`flowCompliant` optional	`boolean`	raise bends to the flow rule minimum (1.5 D)
`frame` optional	`enum`	how the section is carried: "rmf" (default) in the plane normal to the path on a rotation-minimising frame; "axial" in the plane through a helix axis (screw motion — thread forms, square-wire springs; helix paths only); "fixed" translated with its normal held constant. `twist` adds on top of any of them. one of "rmf", "axial", "fixed"
`holes` optional	`object[]`	inner loops subtracted from the section — a swept TUBE (bent pipe). Wind each one the opposite way from the outer section. ≥ 1 items
`keepFailed` optional	`boolean`	—
`maxTurnAngle` optional	`number`	— > 0
`sectionTolerance` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`surfaces` optional	`enum`	Wall surfaces: "analytic" by default on a round { points, bendRadius } tube, else "bspline". "bspline": every wall a B-spline skin (bandStations / wallFaces / exactSection keep it). "analytic" (CADSF-2568: the default there): on a { points, bendRadius } path with a round section (full circles centred on the path) the runs are published as exact CYLINDRICAL_SURFACE faces and the bends as TOROIDAL_SURFACE segments — fast to tessellate, exact volume, and the faces the boolean's analytic rungs take (use it for a tube that will be unioned or cut). Any other path or section is refused by name (tube_sweep_analytic_unsupported). one of "bspline", "analytic"
`twist` optional	`number`	—
`up` optional	`number[]`	[x, y, z] in millimetres exactly 3 items
`wallFaces` optional	`enum`	"segment" (default): a run of section nodes on one arc or straight line is ONE wall face per band; "strip": one wall face per section node (the older layout; same volume). one of "segment", "strip"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_laminate` write Laminate

Bend a laminated or steam-bent member: a rectangular section swept along a spine of straight runs and true corner bends, with an optional lamination count drawn as glue lines.

Full description

Call cad_help({tool:"cad_laminate"}) for the rest.

Argument	Type	Meaning & bounds
`bendRadius` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`layers` optional	`integer`	lamination count. ≥ 0 · ≤ 64
`maxBandAngle` optional	`number`	— > 0
`section` optional	`object`	the rectangular section the member is bent from.
`section.cornerRadius`	`number`	round the section's four corners, mm… ≥ 0
`section.thickness`	`number`	the section's dimension IN the bend plane, mm… > 0
`section.width`	`number`	the section's dimension ALONG the bend axis… > 0
`spine` optional	`object`	the member's centreline: { points, bendRadius \|…
`suppressed` optional	`boolean`	true = not built
`up` optional	`number[]`	[x,y,z] mm exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_lattice_fill` write Lattice fill

Fill a solid's interior with a strut or TPMS-sheet lattice (see cell) under an optional solid skin, publishing a watertight mesh (default, of kept) or, for small results, a B-rep (of consumed) - with volume, density and cell/strut counts.

Full description

Call cad_help({tool:"cad_lattice_fill"}) for the rest.

Argument	Type	Meaning & bounds
`cell` required	`enum`	TPMS (gyroid/schwarzP/schwarzD) uses sheetThick… one of "gyroid", "schwarzP", "schwarzD", "sc", "bcc", "fcc", "octet", "diamond", "kelvin", "bccz", "fccz"
`of` required	`string`	body handle length ≥ 1
`buildDir` optional	`number[]`	[x,y,z] mm exactly 3 items
`cavityH` optional	`number`	extraction grid step, mm; default set from stru… > 0
`cellAspect` optional	`number[]`	[x,y,z] mm exactly 3 items
`cellSize` optional	`number`	cell edge or TPMS period, mm > 0
`density` optional	`object`	graded feature size, mm…
`density.kind`	`enum`	— one of "uniform", "gradient", "field", "distance", "fea", "expr"
`document` optional	`string`	handle or "new" length ≥ 1
`drainHoles` optional	`object`	Vent holes (mm).
`drainHoles.diameter`	`number`	— > 0
`drainHoles.at`	`number[][]`	— ≥ 1 items · ≤ 64 items
`drainHoles.count`	`integer`	— ≥ 1 · ≤ 64
`drainHoles.down`	`number[]`	[x,y,z] mm exactly 3 items
`drainHoles.pockets`	`boolean`	—
`exchanger` optional	`object`	Two-fluid exchanger: {a, b} port face lists…
`fillet` optional	`number`	mm, >= 0 ≥ 0
`frame` optional	`object`	Conformal lattice: cells mapped through the…
`frame.kind`	`enum`	— one of "conformal"
`frame.skinFaces`	`string[]`	— ≥ 1 items · ≤ 256 items
`frame.thickness`	`number`	— > 0
`frame.curved`	`boolean`	—
`h` optional	`number`	extraction grid step, mm; default set from stru… > 0
`keepFailed` optional	`boolean`	—
`keepSolid` optional	`object[]`	Hybrid: faces kept exact B-rep… ≥ 1 items · ≤ 64 items
`maxTriangles` optional	`integer`	— ≥ 1
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`output` optional	`enum`	mesh (default, source kept), brep… one of "mesh", "brep", "field", "hybrid"
`period` optional	`number`	cell edge or TPMS period, mm > 0
`sheetThickness` optional	`number`	TPMS wall thickness, mm > 0
`skin` optional	`number`	solid wall kept inside the surface before the l… ≥ 0
`strutRadius` optional	`number`	strut radius, mm (strut cells) > 0
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_picogk` write

PicoGK voxel ops on bodies, as an async job: offset, shell, smoothen, boolean, TPMS, beam lattice.

Full description

Or cem: build + run your own PicoGK C# project headless (.NET SDK) and import its STL/VDB. Returns jobId; cad_job_result gives the body (to_brep: B-rep) + volume/bbox. mm. Needs the PicoGK add-on. Ops: cad_help.

Argument	Type	Meaning & bounds
`bodies` optional	`string[]`	body handles; ops name them in body/with ≥ 1 items · ≤ 8 items
`cem` optional	`object`	MODE cem (instead of bodies/ops): build and run YOUR PicoGK/ShapeKernel C# project headless (needs the .NET 9 SDK), then import every .stl/.vdb it writes under output_dir as a body. Paths resolve inside CADSOLVER_CEM_ROOT (default the output dir); others are refused. voxel_size_mm is the PicoGK Library voxel size. docs/interop/PICOGK.md.
`cem.entry`	`string`	public static Namespace.Class.Method taking nothing or one string (params JSON), e.g. Leap71.CoolCube.HelixHeatX.Task length ≥ 1
`cem.project_path`	`string`	a .csproj, a folder with one, or a folder of .cs sources (compiled with the PicoGK NuGet package; Program.cs files skipped) length ≥ 1
`cem.maxOutputMB`	`number`	cap on what the run writes into output_dir (default 512) > 0 · ≤ 8192
`cem.output_dir`	`string`	where the run writes; the entry working directory and Library.strLogFolder (default <root>/picogk/cem-<time>) length ≥ 1
`cem.params`	`object`	JSON handed to the entry point (also env NATIVECAD_CEM_PARAMS / NATIVECAD_CEM_PARAMS_FILE)
`document` optional	`string`	document the result lands in (default: the active one)
`dryRun` optional	`boolean`	validate and return the deck; run nothing (no runtime needed)
`import` optional	`boolean`	false (alias resultOnly:true): skip the import and return {stl, vdb, volumeMm3, bbox, triangles} from the host (default true); for printer prep, reports, million-triangle moulds
`jobMode` optional	`boolean`	default true (async job); false runs inline
`maxTriangles` optional	`integer`	decimate the result STL to at most this many triangles (vertex clustering, off-worker) before the import; a result over the worker limit is otherwise refused PICOGK_IMPORT_TOO_LARGE ≥ 1000
`ops` optional	`object[]`	Ops run in order on one field: each reads `on` (a field name; default the previous result) and names its result `as`. voxelize {body} (implicit first op on bodies[0]); offset {distanceMm, + grows}; shell {thicknessMm, inward wall}; smoothen {distanceMm}; boolean {mode: union\|subtract\|intersect, with: field or body} (aliases union/subtract/intersect); implicit {tpms: gyroid\|schwarz_p\|diamond, cellMm, wallMm} TPMS sheet clipped to the field (aliases gyroid/schwarz_p/diamond); lattice {cell: sc\|bcc\|fcc\|octet\|diamond\|kelvin\|bccz\|fccz, cellMm, beamRadiusMm} NativeCAD unit-cell beams rendered by PicoGK, clipped to the field. Args may sit on the op or under `args`. Gyroid core with a 1 mm skin: [{op:"voxelize",as:"part"},{op:"shell",on:"part",thicknessMm:1,as:"skin"},{op:"offset",on:"part",distanceMm:-1},{op:"gyroid",cellMm:6,wallMm:0.8},{op:"union",with:"skin"}]. ≥ 1 items · ≤ 32 items
`outDir` optional	`string`	case directory (default <output dir>/picogk/case-<time>)
`resultOnly` optional	`boolean`	alias of import:false
`timeoutSec` optional	`integer`	host wall clock limit (default 1800); cem: build + run ≥ 1 · ≤ 86400
`to_brep` optional	`boolean`	run cad_mesh_to_brep on the result (STEP-ready body); default: a mesh body
`vdb` optional	`boolean`	also keep the result as OpenVDB (result.vdb in the case directory)
`voxel_size_mm` optional	`number`	PicoGK voxel size, mm (default 0.25); result error is about one voxel > 0 · ≤ 100

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_weave` write Weave

Weave a seat: paper cord, cane or webbing over a seat frame as a real strand pattern, with a coarse slab lod for previews and a fine per-strand lod for renders and export.

Full description

Call cad_help({tool:"cad_weave"}) for the rest.

Argument	Type	Meaning & bounds
`clearance` optional	`number`	—
`coarseLines` optional	`integer`	how many strand centrelines… ≥ 0 · ≤ 64
`cornerInset` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`frame` optional	`object`	the seat frame the weave ha…
`keepFailed` optional	`boolean`	—
`lod` optional	`enum`	the level of detail. one of "coarse", "fine"
`maxStrands` optional	`integer`	— ≥ 1
`pattern` optional	`enum`	the weave. one of "envelope", "plain", "cane"
`sample` optional	`integer`	— ≥ 1
`strand` optional	`object`	the stock the seat is woven…
`strand.diameter`	`number`	a ROUND strand's diameter… > 0
`strand.kind`	`enum`	the stock: 'cord' = Danish… one of "cord", "cane", "webbing"
`strand.pitch`	`number`	the spacing between neighbo… > 0
`strand.sides`	`integer`	how many sides the round se… ≥ 6 · ≤ 64
`strand.thickness`	`number`	a FLAT strand's thickness… > 0
`strand.width`	`number`	a FLAT strand's width, mm… > 0
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0
`wrapSegments` optional	`integer`	— ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_loft_profiles` write Loft profiles

Loft two or more closed planar sections into one solid.

Full description

EITHER profileA+profileB (2-section RULED loft, straight side faces, zA/zB heights default 0/1) OR profiles: [...] (>=3-section CUBIC loft through every intermediate section, e.g. square -> rounded-square -> circle). Call cad_help({tool:"cad_loft_profiles"}) for the rest.

Argument	Type	Meaning & bounds
`breaks` optional	`any[]`	sectionCurve:"spline" only: vertex indices…
`capFit` optional	`enum`	sectionFrame:"spatial" only: how the non-planar… one of "interpolate", "approximate"
`capGrid` optional	`integer`	— ≥ 1
`capGridU` optional	`integer`	— ≥ 1
`capGridV` optional	`integer`	— ≥ 1
`capPlanarTol` optional	`number`	— > 0
`capSamples` optional	`integer`	— ≥ 1
`capTol` optional	`number`	— > 0
`centerline` optional	`number[][]`	polyline, rising z ≥ 2 items
`cornerAngleDeg` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`fallback` optional	`object`	ladder opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`fitTol` optional	`number`	— > 0
`guides` optional	`number[][][]`	guide polylines ≥ 1 items
`keepFailed` optional	`boolean`	—
`levels` optional	`integer`	— ≥ 1
`profileA` optional	`number[][]`	>=3 [x,y], unclosed ≥ 3 items
`profileB` optional	`number[][]`	>=3 [x,y], unclosed ≥ 3 items
`profiles` optional	`array \| object[]`	>=2 sections ≥ 2 items
`sectionCurve` optional	`enum`	must be "polyline"… one of "polyline", "spline"
`sectionFrame` optional	`enum`	must be "planar"… one of "planar", "spatial"
`suppressed` optional	`boolean`	true = not built
`zA` optional	`number`	—
`zB` optional	`number`	—
`zs` optional	`number[]`	—

Exactly one of these argument shapes: profileA + profileB — or — profiles. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_loft_guided` write Guided loft

Loft sections along guide curves and/or a centerline.

Full description

The guide-driven loft. Call cad_help({tool:"cad_loft_guided"}) for the rest.

Argument	Type	Meaning & bounds
`centerline` optional	`number[][]`	polyline, rising z ≥ 2 items
`document` optional	`string`	handle or "new" length ≥ 1
`guides` optional	`number[][][]`	guide polylines ≥ 1 items
`keepFailed` optional	`boolean`	—
`levels` optional	`integer`	— ≥ 1
`profileA` optional	`number[][]`	>=3 [x,y], unclosed ≥ 3 items
`profileB` optional	`number[][]`	>=3 [x,y], unclosed ≥ 3 items
`profiles` optional	`array \| object[]`	>=2 sections ≥ 2 items
`suppressed` optional	`boolean`	true = not built
`zA` optional	`number`	—
`zB` optional	`number`	—
`zs` optional	`number[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_blade` write Blade

Build a REAL turbomachinery blade or vane: an N-section aerofoil loft with twist, a root fillet (lofted, or a true rolling-ball blend), a platform with overhangs, a shank with angel wings, a dovetail or fir-tree root, and optional internal cooling (serpentine, film holes, TE slots), as ONE solid body.

Full description

Takes NO of — this op BUILDS a body. Call cad_help({tool:"cad_blade"}) for the rest.

Argument	Type	Meaning & bounds
`angelWings` optional	`object`	ANGEL-WING seals…
`angelWings.aft`	`boolean`	downstream (+y) w…
`angelWings.drop`	`number`	platform undersid… ≥ 0
`angelWings.fore`	`boolean`	upstream (-y) win…
`angelWings.length`	`number`	axial reach out o… > 0
`angelWings.lip`	`number`	upturn at the tip… ≥ 0
`angelWings.thickness`	`number`	wing thickness, mm > 0
`angelWings.width`	`number`	tangential width… > 0
`bow` optional	`number`	—
`bowAxial` optional	`number`	—
`cooling` optional	`object`	INTERNAL COOLING…
`cooling.hubGap`	`number`	cavity floor abov… ≥ 0
`cooling.inlet`	`boolean`	feed pass 1 throu…
`cooling.inletWidth`	`number`	inlet width… > 0
`cooling.levels`	`integer`	fitted radial lev… ≥ 3 · ≤ 40
`cooling.minPassage`	`number`	smallest passage… ≥ 0.2 · ≤ 20
`cooling.passes`	`integer`	radial passes of… ≥ 1 · ≤ 6
`cooling.pressureSide`	`object`	PRESSURE-SIDE fil…
`cooling.ribWidth`	`number`	rib between passe… ≥ 0.2 · ≤ 20
`cooling.showerhead`	`object`	leading-edge SHOW…
`cooling.teSlots`	`object`	TRAILING-EDGE SLO…
`cooling.tipWall`	`number`	metal above the c… ≥ 0.2
`cooling.turnHeight`	`number`	height of each 18… ≥ 0.2
`cooling.wall`	`number`	minimum wall betw… ≥ 0.2 · ≤ 10
`document` optional	`string`	handle or "new" length ≥ 1
`dovetail` optional	`object`	the DOVETAIL ROOT…
`dovetail.depth`	`number`	total radial dept… > 0
`dovetail.baseWidth`	`number`	tangential width… > 0
`dovetail.chamfer`	`number`	break on the two… ≥ 0
`dovetail.flankFraction`	`number`	fraction of `dept… > 0 · ≤ 0.95
`dovetail.neckFraction`	`number`	fraction of `dept… ≥ 0 · ≤ 0.9
`dovetail.neckWidth`	`number`	tangential width… > 0
`embed` optional	`number`	—
`emit` optional	`string`	a string — for…
`fillet` optional	`object`	the ROOT FILLET…
`fillet.radius`	`number`	fillet radius, mm… ≥ 0
`fillet.kind`	`enum`	CADSF-101414: "bl… one of "blend", "lofted"
`fillet.steps`	`integer`	how many section… ≥ 1
`firtree` optional	`object`	a multi-lobe FIR-…
`firtree.flankAngle`	`number`	CONTACT flank ang… ≥ 10 · ≤ 70
`firtree.lobeRadius`	`number`	radius of the con… > 0
`firtree.lobeWidth`	`number`	MAXIMUM tangentia… > 0
`firtree.lobeWidths`	`number[]`	per-lobe maximum…
`firtree.lobes`	`integer`	number of lobes p… ≥ 1 · ≤ 6
`firtree.lowerFlankAngle`	`number`	lower (non-contac… ≥ 20 · ≤ 85
`firtree.neckRadius`	`number`	radius of the con… > 0
`firtree.neckWidth`	`number`	MINIMUM tangentia… > 0
`firtree.neckWidths`	`number[]`	per-neck minimum…
`firtree.wedgeAngle`	`number`	included taper an… ≥ 0 · ≤ 60
`footMargin` optional	`number`	—
`join` optional	`enum`	"imprint"… one of "imprint", "union"
`keepFailed` optional	`boolean`	—
`leSteps` optional	`number`	— > 0
`lean` optional	`number`	—
`leanDeg` optional	`number`	—
`miterLimit` optional	`number`	— > 0
`platform` optional	`object`	the PLATFORM…
`platform.length`	`number`	AXIAL length, mm > 0
`platform.thickness`	`number`	radial thickness, mm > 0
`platform.width`	`number`	TANGENTIAL width… > 0
`platform.axialCentre`	`number`	axial centre of t…
`platform.chamfer`	`number`	break on the two… ≥ 0
`platform.overhangAft`	`number`	CADSF-101414: how… ≥ 0
`platform.overhangFore`	`number`	CADSF-101414: how… ≥ 0
`platform.tangentialCentre`	`number`	tangential centre…
`points` optional	`number`	— > 0
`root` optional	`enum`	the root form bel… one of "dovetail", "firtree", "none"
`rotor` optional	`object`	TPI [3]: build a…
`rotor.blades`	`integer`	main blade count ≥ 2 · ≤ 40
`rotor.assumptions`	`object`	provenance notes…
`rotor.backplate`	`object \| boolean`	{thickness, stock…
`rotor.beta`	`object`	blade angles in D…
`rotor.flankPoints`	`integer`	points per blade… ≥ 4 · ≤ 40
`rotor.hub`	`object`	{bore (DIAMETER)…
`rotor.hubArcPoints`	`integer`	points per hub ar… ≥ 1 · ≤ 20
`rotor.kind`	`enum`	default impeller one of "impeller", "inducer", "wheel"
`rotor.leanDeg`	`number`	constant hub-to-s…
`rotor.meridional`	`object`	the meridional co…
`rotor.process`	`object`	{minWall…
`rotor.rakeDeg`	`number`	TE rake, deg: the…
`rotor.ruled`	`boolean`	ruled (flank-mill…
`rotor.shroud`	`object`	closed impeller…
`rotor.splitters`	`object \| boolean \| number`	{start} = one spl…
`rotor.stations`	`integer`	axial loft statio… ≥ 4 · ≤ 60
`rotor.thickness`	`object`	NORMAL blade thic…
`rotor.wrapMatch`	`enum`	give every span t… one of "shroud", "hub", "none"
`sections` optional	`object[]`	the aerofoil SECT… ≥ 2 items
`shank` optional	`object`	the SHANK between…
`shank.height`	`number`	radial height, mm… ≥ 0
`shank.topWidth`	`number`	tangential width… > 0
`spanLevels` optional	`number`	—
`squealerDepth` optional	`number`	— > 0
`squealerRim` optional	`number`	— > 0
`stack` optional	`string`	a string — for…
`suppressed` optional	`boolean`	true = not built
`sweep` optional	`number`	—
`sweepDeg` optional	`number`	—
`teSteps` optional	`number`	— > 0
`tip` optional	`string`	a string — for…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_thicken` destructive Thicken

Thicken a sheet (open) body into a closed solid by offsetting it along its own face normal.

Full description

of names a SHEET body — a planar_sheet result (CADSF-541), or a stitch result that did NOT close (see each op's own description) — NOT an ordinary solid. Call cad_help({tool:"cad_thicken"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`thickness` optional	`number`	—
`thickness1` optional	`number`	—
`thickness2` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_shell` destructive Shell

Hollow a planar-faced solid to a wall thickness, opening the named faces.

Full description

Shell the plain blank BEFORE adding holes/bosses/fillets, with open faces named by normal; a part whose fillet radius ≤ thickness refuses with shell-radius-collapse. Retires of. Call cad_help({tool:"cad_shell"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`thickness` required	`number`	— > 0
`budgetMs` optional	`number`	—
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`fallback` optional	`object`	ladder policy: maxRung = last rung (index or id); allowDegraded (default false) / allowTolerant (default true) admit degrading / tolerant rungs; disable = rung ids. A refusal's retry.argsPatch names the opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`keepFailed` optional	`boolean`	—
`open` optional	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both (an empty array selects nothing, which is meaningful for shell's "open")
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_rib` write Rib

Thicken an OPEN path into a standing stiffener wall, unioned into a base solid.

Full description

Retires of. Profile is EITHER inline path ([[x,y],...], open polyline, >=2 pts) OR profile: { sketch, entity? } (an open sketch entity). Call cad_help({tool:"cad_rib"}) for the rest.

Argument	Type	Meaning & bounds
`height` required	`number`	— > 0
`of` required	`string`	body handle length ≥ 1
`thickness` required	`number`	— > 0
`attachZ` optional	`number`	—
`direction` optional	`enum`	"linear" (default): thickne… one of "linear", "normal"
`document` optional	`string`	handle or "new" length ≥ 1
`draft` optional	`number \| object`	draft taper (radians): a nu…
`embed` optional	`number`	— > 0
`endHeight` optional	`number`	— > 0
`face` optional	`object \| string`	a face selector
`filletSteps` optional	`integer`	— ≥ 1
`keepFailed` optional	`boolean`	—
`path` optional	`any[]`	the rib's open path
`profile` optional	`object`	a rib's OPEN path taken fro…
`profile.sketch`	`string`	the "id" of an earlier op i… length ≥ 1
`profile.entity`	`string`	the open entity id within t… length ≥ 1
`projectionTol` optional	`number`	— > 0
`pull` optional	`number[]`	[x,y,z] mm exactly 3 items
`rootFillet` optional	`number`	mm, >= 0 ≥ 0
`side` optional	`enum`	which side of the path the… one of "both", "symmetric", "left", "right"
`suppressed` optional	`boolean`	true = not built
`tipFillet` optional	`number`	mm, >= 0 ≥ 0

Exactly one of these argument shapes: path — or — profile. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_draft` destructive Draft

Taper selected walls away from a neutral plane — the mould-release feature.

Full description

Retires of, publishes ONE new solid. Call cad_help({tool:"cad_draft"}) for the rest.

Argument	Type	Meaning & bounds
`faces` required	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both
`neutral` required	`object`	the NEUTRAL PLANE: the plane the drafted faces pivot about, so geometry lying in it does not move. Its normal also supplies the default pull direction. It must be transverse to the pull — a neutral plane parallel to the pull separates nothing and is refused.
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`angle` optional	`number`	—
`angles` optional	`object`	PER-FACE draft angles, keyed by raw STEP face id — a variable-angle draft in the sense that different walls taper by different amounts (an angle that varies ALONG one wall is not supported). Overrides `angle` for the faces it names; every face in `faces` needs one or the other. ≥ 1 keys
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`fallback` optional	`object`	ladder policy: maxRung = last rung (index or id); allowDegraded (default false) / allowTolerant (default true) admit degrading / tolerant rungs; disable = rung ids. A refusal's retry.argsPatch names the opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`keepFailed` optional	`boolean`	—
`parting` optional	`boolean`	—
`pull` optional	`number[]`	[x, y, z] in millimetres exactly 3 items
`strictCheck` optional	`boolean`	—
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fillet_edges` destructive Fillet edges

Fillet (round) edges — constant radius, tip-weighted, law-driven variable radius around a rim, or a selected subset.

Full description

Blanket fillets partition: convex edges get rounded, edges that cannot be filleted are listed under partition.skipped with a reason code — read it rather than retrying with the same radius. Call cad_help({tool:"cad_fillet_edges"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`at` optional	`string`	a string — for blend's `at`, one of "base" \| "top" \| "tip" \| "all" (revolved-body fallback selector; see commands/schema.md's blend section)
`continuity` optional	`string`	a string — for blend's `at`, one of "base" \| "top" \| "tip" \| "all" (revolved-body fallback selector; see commands/schema.md's blend section)
`corner` optional	`number`	— > 0
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`edges` optional	`array \| object \| string`	a edge selection: a raw edge id, a declarative selector object, or an array mixing both
`engine` optional	`enum`	which engine may build the fillet. "brep" (default) is the exact B-rep rolling ball only, unchanged. "auto" / "implicit" try the B-rep FIRST and fall through to an implicit smooth-union fillet only when it refuses with blend_cyl_pinch_degenerate or saddle-runs-off-wall AND the body carries lattice provenance (a registered strut union); any other refusal stays a refusal. The implicit answer is a watertight MESH (not B-rep faces) reported with engine "implicit", k, h and its calibration, and is itself refused (implicit_fillet_degenerate) below a 20 degree minimum dihedral or when not watertight. "implicit" on a body without lattice provenance refuses implicit_fillet_not_lattice; "auto" there is plain B-rep one of "brep", "auto", "implicit"
`fallback` optional	`object`	ladder policy: maxRung = last rung (index or id); allowDegraded (default false) / allowTolerant (default true) admit degrading / tolerant rungs; disable = rung ids. A refusal's retry.argsPatch names the opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`keepFailed` optional	`boolean`	—
`law` optional	`string`	a law: a scalar expression in the parameter `t` (`theta` is a synonym), e.g. "1 + 0.5sin(3t)". Operators + - * / ^ (^ is power, right-associative) and parentheses; functions abs, acos, asin, atan, atan2, ceil, cos, exp, floor, log, log10, max, min, pow, round, sign, sin, sqrt, tan; constants PI, E; and any named parameter of the document. For a blend, `t` is the angle in RADIANS around the rim (0..2π) and the value is the fillet radius in mm, so the law must come back to itself at 2π — use whole multiples of t inside sin/cos (sin(3t), not sin(2.5t)). This is not JavaScript or Python: no `**`, no `Math.`, no assignments, no function definitions. length 1–512
`lobes` optional	`integer`	— ≥ 1
`max` optional	`number`	— > 0
`mid` optional	`number`	— > 0
`min` optional	`number`	— > 0
`order` optional	`enum`	the order the radius LEVELS of a grouped blend are applied in. "auto" (default) is largest radius first — the ordering the kernel derives, because a large blend band cannot end on a small finished one; "input" applies them in the order given, which is how you reproduce a sequential result and is REFUSED by name (BLEND_GROUP_MIXED_RADIUS_VERTEX) when the order does not fit one of "auto", "input"
`partial` optional	`boolean`	—
`perEdge` optional	`object[]`	per-edge fillet radii for a grouped blend — every edge named must also appear in "edges"; any selected edge not named here takes the op's own "radius"/"corner" ≥ 1 items
`phase` optional	`number`	—
`pinchMinTipDeg` optional	`number`	—
`propagate` optional	`boolean`	—
`radius` optional	`number`	— > 0
`rho` optional	`number`	— > 0
`setback` optional	`enum`	setback at a vertex patch. "auto" only: the distance is DETERMINED by the corner geometry (ops/vertexBlend.js) — a numeric setback is refused by name (BLEND_GROUP_SETBACK_FIXED). Passing "auto" is not a no-op: it selects the grouped route, with its per-corner classification report, for a uniform-radius selection one of "auto"
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`toolMatch` optional	`boolean \| object \| string`	CADSF-636 — match this feature to the shop's stocked tooling so it prices at the lowest tool-matched tier. Default (field omitted) is ADVISORY: the result entry carries a `toolMatch` record with the nearest stocked drill / ball-mill radius, the delta, and a machine-applicable `fix` {field, value} — and the geometry is untouched. Pass "snap" to opt in and have the dimension replaced. A tapped hole is exempt (its drill Ø is fixed by the thread). CADSB-517: pass `process` to name the manufacturing route — on a route with no stocked-tool catalogue, matching is suppressed entirely.
`variable` optional	`object`	ONE fillet band whose radius changes along a chain of straight edges between planar faces (CADSF-1043). Requires "edges" naming an OPEN chain (consecutive edges sharing a vertex, every edge convex). The sections are circular arcs of the local radius, tangent to both faces everywhere; the band is a B_SPLINE_SURFACE_WITH_KNOTS whose measured miss is declared as an edge tolerance. Each chain end must meet a planar cap perpendicular to its edge; an interior vertex must be a convex trihedral corner. Anything else refuses by name (BLEND_VARIABLE_*) with the input body unchanged. The same band is what a grouped blend (perEdge) falls back to where its stepped plan would refuse BLEND_GROUP_MIXED_RADIUS_VERTEX on such a chain
`variable.radii`	`number[]`	radius control values at the VERTICES of the picked chain, in chain order starting at the free end of the first listed edge — one more value than there are edges (two for a single edge: its two ends) ≥ 2 items
`variable.law`	`enum`	how the radius runs between two controls along the chain arclength: "linear" (default) or "smooth" (a C1 cubic that is flat at every control) one of "linear", "smooth"

Exactly one of these argument shapes: radius — or — corner + mid — or — min + max — or — law. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_face_blend` destructive Face blend / full round

Blend between two face sets that need not touch; omit the radius for the three-face blend (full round).

Full description

Call cad_help({tool:"cad_face_blend"}) for the rest.

Argument	Type	Meaning & bounds
`left` required	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`right` required	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both
`crossSection` optional	`string`	a string — for blend's `at`, one of "base" \| "top" \| "tip" \| "all" (revolved-body fallback selector; see commands/schema.md's blend section)
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`holdLine` optional	`string`	a string — for blend's `at`, one of "base" \| "top" \| "tip" \| "all" (revolved-body fallback selector; see commands/schema.md's blend section)
`keepFailed` optional	`boolean`	—
`middle` optional	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both (an empty array selects nothing, which is meaningful for shell's "open")
`radius` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_ease_edges` destructive Ease exposed edges

Ease every EXPOSED edge to the maker's radius (fillet, chamfer fallback), leaving faces that mate with other parts sharp.

Full description

Radius from radius or rule ("hardwood" 2 mm, "plywood" 1 mm, "aluminium" 1.5 mm); mating faces from mateWith ("auto": touching any other body) or excludeFaces. Call cad_help({tool:"cad_ease_edges"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`chamferDistance` optional	`number`	— > 0
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`excludeFaces` optional	`string[]`	an array of raw STEP face id strings (may be empty — an empty list means "open no faces")
`fallback` optional	`enum`	default "chamfer" - what runs on the same edges when the kernel refuses the fillet; "none" refuses instead; "partial" (CADSB-100571) chamfers, and when that refuses too builds the edges that DO take the fillet and names each one it could not in ease.unbuilt - a best-effort finish instead of an all-or-nothing refusal one of "chamfer", "none", "partial"
`keepFailed` optional	`boolean`	—
`mateWith` optional	`array \| string`	which bodies this one mates with: faces touching them are never eased
`radius` optional	`number`	— > 0
`rule` optional	`string`	the maker's edge rule the radius comes from (its band's typical value): a material kind - "hardwood"/"softwood" (2 mm, band 1-3), "plywood" (1 mm, band 0.5-1), "veneer-laminate" (0.8 mm), "aluminium"/"plastic" (cast/moulded parting line, 1.5 mm) - or a furniture-construction pack entry id ("finish-edge-solid-hardwood", "furniture-construction/finish-edge-ply-laminate"). "steel" (tube ends are capped) and soft parts refuse ease-rule-no-radius. An explicit "radius" wins over the rule's. length ≥ 1
`sharpDeg` optional	`number`	default 170 - a convex edge whose interior dihedral is under this is "sharp" (unbroken) and is eased > 90 · < 180
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

Exactly one of these argument shapes: radius — or — rule. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_chamfer_edges` destructive Chamfer edges

Flat bevel on selected convex edges, or on every convex edge.

Full description

Retires of. distance is the symmetric setback (mm) — the flat-bevel twin of blend. Call cad_help({tool:"cad_chamfer_edges"}) for the rest.

Argument	Type	Meaning & bounds
`distance` required	`number`	— > 0
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`angle` optional	`number`	the DISTANCE-ANGLE spelling of a chamfer (T-FLEX's "length-angle" — the machinist's callout, e.g. a 0.8 x 45deg edge break is distance-angle, not two distances). RADIANS, measured from the picked edge's FIRST support face (see "distance2"'s note on which face that is) to the chamfer plane; strictly between 0 and PI/2 (0deg and 90deg exclusive — a bevel needs to actually lean). The second setback is derived as distance * tan(angle) and reported as setbacks[].d2, so a 45deg angle reproduces the plain symmetric "distance" chamfer exactly (tan(45deg) = 1) — which is why a 45deg chamfer never needed this field; anything else was unreachable before CADSF-1612. Requires "edges" and may not be combined with "distance2". > 0 · < 1.5707963267948966
`distance2` optional	`number`	the SECOND setback (mm) — a distance-distance / asymmetric chamfer (OCCT's Add(d1,d2)). "distance" (the existing field) is always the setback against the picked edge's FIRST support face, this one against its SECOND. Requires "edges" (an asymmetric setback is a statement about a specific edge's two faces, and a whole-body chamfer — no "edges" — never resolves which face that is) and may not be combined with "angle" — they are two spellings of the same second setback. Which face is "first"/"second" is NOT the pick order: it is the order the body's own topology reports the edge's two support faces in, and it is EXPLICIT and DETERMINISTIC for a given body/edge — the result names it exactly, on setbacks[].faces = [firstFaceId, secondFaceId], alongside the d1/d2 that was actually built, so no caller ever has to guess. > 0
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`edges` optional	`array \| object \| string`	a edge selection: a raw edge id, a declarative selector object, or an array mixing both
`flip` optional	`boolean`	FLIP the asymmetric pair: exchange which of the picked edge's two support faces takes "distance" and which takes the second setback ("distance2", or distance * tan(angle) for "angle"). Default false. Requires "distance2" or "angle" (an equal-distance chamfer has no second setback to swap; flip:true without one is refused as chamfer-asymmetric-unsupported). Removed volume is unchanged — it is the SIDE that moves; the result reports the swap on entry.flipped and the d1/d2 actually built on setbacks[].
`keepFailed` optional	`boolean`	—
`propagate` optional	`boolean`	—
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_drill_hole` destructive Drill hole

Standards-driven manufacturing hole: plain drill, tapped, counterbore, or countersink, with the machinist-facing callout (thread spec / drill size / C'bore / CSK dims) computed from ISO 261 / ISO 273 / ISO 4762 / ISO 10642 tables.

Full description

Retires of. Call cad_help({tool:"cad_drill_hole"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`angle` optional	`number`	with `at`: tilt of the drilling axis off the surface normal, in RADIANS, in the MERIDIAN plane (the plane through the revolve axis and the pick point) — the way a leaning port on a case leans. Must be inside ±90°. NOTE: a tilted axis is no longer perpendicular to the revolve axis, so it leaves the analytic rungs (ops/cylTorusEdge.js's closed form needs a radial axis) and falls to the general engine.
`at` optional	`number[]`	PICK POINT [x, y, z] on the target face — the mouth of the hole, said by pointing at the wall instead of by typing an axis. The drilling axis is that face's outward normal there, RADIAL on a cylindrical, conical or toroidal wall (a cone's true normal leans off radial by its half-angle and a torus's by its meridian angle; neither is a direction any analytic rung pierces, and radial is what a case's ports are). A blind `depth` is measured from the wall's own outer surface along that axis, and a through hole spans the WALL plus a margin — the wall being read off the solid, not off its bounding box. Excludes `center` and `start`. exactly 3 items
`axis` optional	`number[]`	drilling DIRECTION [x, y, z] (magnitude ignored) — the drill travels this way INTO the material. Requires `start` and excludes `center`; omit both for the default top-face hole (equivalent to axis [0, 0, -1]). exactly 3 items
`center` optional	`number[]`	[x, y] of the hole axis in millimetres (the axis runs +Z through the part's top face). CADSF-582: for any other direction give `axis` + `start` instead of `center`. exactly 2 items
`counterbore` optional	`object`	override the ISO 4762 counterbore dimensions derived from `size` (CADSB-167: use `diameter`, or the deprecated `dia` alias)
`counterbore.depth`	`number`	counterbore depth below the top face, mm — must be less than both the part thickness and the hole depth > 0
`counterbore.dia`	`number`	(deprecated alias for `diameter`, CADSB-167) counterbore diameter, mm > 0
`counterbore.diameter`	`number`	counterbore diameter, mm > 0
`counterbore.pilotDia`	`number`	pilot (through) hole diameter, mm — defaults to the ISO 273 medium clearance for `size` > 0
`countersink` optional	`object`	override the ISO 10642 countersink dimensions derived from `size` (CADSB-167: use `diameter`, or the deprecated `dia` alias)
`countersink.angle`	`number`	included angle in DEGREES (not radians — this is a drawing callout, not a geometric angle); default 90 > 0 · < 180
`countersink.dia`	`number`	(deprecated alias for `diameter`, CADSB-167) countersink (mouth) diameter, mm > 0
`countersink.diameter`	`number`	countersink (mouth) diameter, mm > 0
`countersink.pilotDia`	`number`	pilot (through) hole diameter, mm — defaults to the ISO 273 medium clearance for `size` > 0
`depth` optional	`number`	— > 0
`diameter` optional	`number`	— > 0
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`face` optional	`string`	with `at`: the raw STEP face id to pick on, when the pick point is near more than one face. Omitted, the nearest face wins.
`fit` optional	`string`	— length ≥ 1
`keepFailed` optional	`boolean`	—
`size` optional	`string`	— length ≥ 1
`start` optional	`number[]`	with `axis`: the mouth centre [x, y, z] in millimetres — a point on the hole axis at the surface where the drill enters. A blind `depth` is measured from this point along `axis` (a through hole runs from here through the whole body). exactly 3 items
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`thread` optional	`enum`	"modelled" = the real ISO 68-1 helical thread as geometry (tapped hole / bolt shank); default "cosmetic" = plain cylinder + callout. one of "cosmetic", "modelled"
`through` optional	`boolean`	—
`tip` optional	`boolean \| number \| object`	DRILL POINT (CADSF-1561): a blind hole ends in a CONE at the tool's included point angle — its base at `depth` and its apex (diameter/2)/tan(angle/2) further along the axis (Ø20 at 118° → 6.0 mm). `depth` stays the FULL-DIAMETER depth (drawing convention: depth to the shoulder, the point is extra). DEFAULT for a blind type "drill" hole on a planar face is 118°; pass false for a flat bottom (a machinist's exception, e.g. a milled pocket or a reamed seat). Through holes and holes whose depth reaches the far face have no point; tapped / counterbore / countersink holes and holes on a CURVED wall default to flat — pass a tip to point them. The result's `feature.tip` reports { angle, depth, built }. A point whose apex would break the far face is refused by name (shorten `depth`, drill through, or tip:false).
`toolMatch` optional	`boolean \| object \| string`	CADSF-636 — match this feature to the shop's stocked tooling so it prices at the lowest tool-matched tier. Default (field omitted) is ADVISORY: the result entry carries a `toolMatch` record with the nearest stocked drill / ball-mill radius, the delta, and a machine-applicable `fix` {field, value} — and the geometry is untouched. Pass "snap" to opt in and have the dimension replaced. A tapped hole is exempt (its drill Ø is fixed by the thread). CADSB-517: pass `process` to name the manufacturing route — on a route with no stocked-tool catalogue, matching is suppressed entirely.
`type` optional	`enum`	default "drill". "drill" takes `diameter`; the other three take `size` (e.g. "M8") and read their dimensions out of ops/holes.js's ISO 261 / 273 / 4762 / 10642 tables. "tapped" also accepts ASME B1.1 Unified sizes (UNC/UNF #0 to 1", plus 1-32 UN): "1/4-20 UNC", "1/4-20", "#10-32 UNF", "1-32 UN", optional "-2B" class; the bore is the 75%-thread tap drill (1/4-20 -> #7, 5.105 mm) and the callout reads e.g. "1/4-20 UNC-2B ↧6.4, TAP DRILL #7 ↧8" one of "drill", "tapped", "counterbore", "countersink"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_hole_pattern` write Hole pattern

Array ONE hole feature across a bolt circle, a linear run, an XY grid, a point list, a revolve wall's polar or axial row, or a tube's radial rows — the whole pattern in one op.

Full description

Retires of. Call cad_help({tool:"cad_hole_pattern"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`pattern` required	`object`	where the holes go. One of SEVEN kinds. On a PLANAR top face — "linear", "grid", "circular" (the bolt circle) or "points", each an [x, y] station. On a CURVED wall of a revolve (CADSF-1305) — "polar" ({kind:"polar", radius, station?, count, startAngle?, totalAngle?, axis?, origin?}: N holes AROUND the revolve axis at one height, the port ring) and "axial" ({kind:"axial", radius, angle?, station?, step, count}: N holes ALONG the axis at one clocking, the bolt line). Both emit a 3-D pick point and take their axis from the wall, so `radius` need only be the wall's approximate radius there — the pick is snapped onto the face it lands on. Millimetres and radians; every count INCLUDES the seed instance. CADSF-101574: "radial" ({kind:"radial", rows:[{station, count, diameter?, startAngle?, stagger?, walls?}], axis?, origin?}) cuts rows of plain radial THROUGH holes in the coaxial walls of a tube / tube-in-a-tube in ONE pass (the radial_hole_pattern op).
`angle` optional	`number`	with `at`: tilt of the drilling axis off the surface normal, in RADIANS, in the MERIDIAN plane (the plane through the revolve axis and the pick point) — the way a leaning port on a case leans. Must be inside ±90°. NOTE: a tilted axis is no longer perpendicular to the revolve axis, so it leaves the analytic rungs (ops/cylTorusEdge.js's closed form needs a radial axis) and falls to the general engine.
`counterbore` optional	`object`	override the ISO 4762 counterbore dimensions derived from `size` (CADSB-167: use `diameter`, or the deprecated `dia` alias)
`counterbore.depth`	`number`	counterbore depth below the top face, mm — must be less than both the part thickness and the hole depth > 0
`counterbore.dia`	`number`	(deprecated alias for `diameter`, CADSB-167) counterbore diameter, mm > 0
`counterbore.diameter`	`number`	counterbore diameter, mm > 0
`counterbore.pilotDia`	`number`	pilot (through) hole diameter, mm — defaults to the ISO 273 medium clearance for `size` > 0
`countersink` optional	`object`	override the ISO 10642 countersink dimensions derived from `size` (CADSB-167: use `diameter`, or the deprecated `dia` alias)
`countersink.angle`	`number`	included angle in DEGREES (not radians — this is a drawing callout, not a geometric angle); default 90 > 0 · < 180
`countersink.dia`	`number`	(deprecated alias for `diameter`, CADSB-167) countersink (mouth) diameter, mm > 0
`countersink.diameter`	`number`	countersink (mouth) diameter, mm > 0
`countersink.pilotDia`	`number`	pilot (through) hole diameter, mm — defaults to the ISO 273 medium clearance for `size` > 0
`depth` optional	`number`	— > 0
`diameter` optional	`number`	— > 0
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`face` optional	`object \| string`	a face selector: raw STEP id \| { normal:[x,y,z] } \| { normal:[x,y,z], through:[x,y,z] } \| { surface:"cylinder" } \| { ref:"<provenance tag>" }
`fit` optional	`string`	— length ≥ 1
`keepFailed` optional	`boolean`	—
`size` optional	`string`	— length ≥ 1
`skipFailures` optional	`boolean`	—
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`through` optional	`boolean`	—
`tip` optional	`boolean \| number \| object`	DRILL POINT (CADSF-1561): a blind hole ends in a CONE at the tool's included point angle — its base at `depth` and its apex (diameter/2)/tan(angle/2) further along the axis (Ø20 at 118° → 6.0 mm). `depth` stays the FULL-DIAMETER depth (drawing convention: depth to the shoulder, the point is extra). DEFAULT for a blind type "drill" hole on a planar face is 118°; pass false for a flat bottom (a machinist's exception, e.g. a milled pocket or a reamed seat). Through holes and holes whose depth reaches the far face have no point; tapped / counterbore / countersink holes and holes on a CURVED wall default to flat — pass a tip to point them. The result's `feature.tip` reports { angle, depth, built }. A point whose apex would break the far face is refused by name (shorten `depth`, drill through, or tip:false).
`toolMatch` optional	`boolean \| object \| string`	CADSF-636 — match this feature to the shop's stocked tooling so it prices at the lowest tool-matched tier. Default (field omitted) is ADVISORY: the result entry carries a `toolMatch` record with the nearest stocked drill / ball-mill radius, the delta, and a machine-applicable `fix` {field, value} — and the geometry is untouched. Pass "snap" to opt in and have the dimension replaced. A tapped hole is exempt (its drill Ø is fixed by the thread). CADSB-517: pass `process` to name the manufacturing route — on a route with no stocked-tool catalogue, matching is suppressed entirely.
`type` optional	`enum`	default "drill". "drill" takes `diameter`; the other three take `size` (e.g. "M8") and read their dimensions out of ops/holes.js's ISO 261 / 273 / 4762 / 10642 tables. "tapped" also accepts ASME B1.1 Unified sizes (UNC/UNF #0 to 1", plus 1-32 UN): "1/4-20 UNC", "1/4-20", "#10-32 UNF", "1-32 UN", optional "-2B" class; the bore is the 75%-thread tap drill (1/4-20 -> #7, 5.105 mm) and the callout reads e.g. "1/4-20 UNC-2B ↧6.4, TAP DRILL #7 ↧8" one of "drill", "tapped", "counterbore", "countersink"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_feature_pattern` destructive Pattern a feature (pad / pocket / hole) inside one body

Repeat a pad, pocket or hole already on a body, linear or circular, inside that ONE body (pattern copies whole bodies).

Full description

Pass the pad/pocket/hole as both of and feature; count includes the seed; linear: step [dx,dy,dz]; circular: center (+ axis, totalAngle). Retires of, publishes ONE body. Call cad_help({tool:"cad_feature_pattern"}) for the rest.

Argument	Type	Meaning & bounds
`count` required	`integer`	an integer >= 2 ≥ 2
`feature` required	`string`	body handle length ≥ 1
`of` required	`string`	body handle length ≥ 1
`type` required	`enum`	"linear" (needs "step") or "circular"… one of "linear", "circular"
`axis` optional	`number[]`	[x,y,z] mm exactly 3 items
`center` optional	`number[]`	[x,y,z] mm exactly 3 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`step` optional	`number[]`	[x,y,z] mm exactly 3 items
`suppressed` optional	`boolean`	true = not built
`totalAngle` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_engrave_text` write Engrave text

Engrave arbitrary text (A-Z a-z 0-9 punctuation) into one planar OR CYLINDRICAL face as a watertight pocket.

Full description

Retires of. Needs text, face (selector) and either height (cap height, mm) or fit: {width,height} (auto-scale into a bounding box). Call cad_help({tool:"cad_engrave_text"}) for the rest.

Argument	Type	Meaning & bounds
`face` required	`object \| string`	a face selector
`of` required	`string`	body handle length ≥ 1
`text` required	`string`	— length ≥ 1
`align` optional	`enum`	— one of "left", "center", "right"
`angleDeg` optional	`number`	—
`arcTolerance` optional	`number`	— > 0
`autoFit` optional	`boolean`	—
`chordTolerance` optional	`number`	— > 0
`curveEdges` optional	`boolean`	—
`curveTolerance` optional	`number`	— > 0
`cutterDiameter` optional	`number`	— > 0
`depth` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`draft` optional	`number`	—
`embolden` optional	`number`	— > 0
`fit` optional	`object`	—
`fit.height`	`number`	bounding-box height to auto… > 0
`fit.width`	`number`	bounding-box width to auto-… > 0
`font` optional	`string`	a bundled outline-font id… length ≥ 1
`gapCols` optional	`number`	—
`height` optional	`number`	— > 0
`keepFailed` optional	`boolean`	—
`legibility` optional	`object \| string`	—
`lineBreaks` optional	`number[]`	—
`lineHeightFrac` optional	`number`	— > 0
`lines` optional	`string[]`	non-empty strings ≥ 1 items
`maxLines` optional	`integer`	a positive integer ≥ 1
`maxTurnDeg` optional	`number`	—
`minHeight` optional	`number`	— > 0
`orient` optional	`array \| string`	which way the text points…
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`rotate` optional	`number`	—
`spacing` optional	`number`	—
`stations` optional	`object`	—
`stations.count`	`integer`	number of stations round th… ≥ 1
`stations.labels`	`string[]`	explicit per-station labels…
`stations.startDeg`	`number`	angle of the first station…
`stations.startNumber`	`integer`	first station number substi…
`stations.stepDeg`	`number`	angle between stations, deg…
`stencil` optional	`boolean \| object`	—
`suppressed` optional	`boolean`	true = not built
`through` optional	`boolean`	—
`vAlign` optional	`enum`	baseline-anchored by defaul… one of "baseline", "middle", "center", "top"
`z` optional	`number`	—

Exactly one of these argument shapes: height — or — fit. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_pushpull` destructive Push / pull a face

Direct-edit press/pull: offset a planar face along its normal.

Full description

Retires of. faceId (raw STEP id, like delete_face) names the face; mode ("add"|"remove") picks material addition vs removal; distance (mm, >0) is the offset. Blind (fixed-distance) end condition only.

Argument	Type	Meaning & bounds
`distance` required	`number`	— > 0
`faceId` required	`string`	— length ≥ 1
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`mode` optional	`enum`	"add" = add material, "remove" = cut material one of "add", "remove"
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_move_face` destructive Move face

Direct edit: move one face (plane, cylinder, cone or sphere) and regenerate its neighbours.

Full description

Retires of, publishes ONE new solid. Call cad_help({tool:"cad_move_face"}) for the rest.

Argument	Type	Meaning & bounds
`faceId` required	`string`	— length ≥ 1
`of` required	`string`	body handle length ≥ 1
`check` optional	`enum`	which ops/check tier runs on the moved body. one of "none", "local", "full"
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`offset` optional	`number`	—
`rotate` optional	`object`	tilt the face: a rotation about an arbitrary axis.
`rotate.angle`	`number`	rotation angle about `axis`, in RADIANS.
`rotate.axis`	`number[]`	the rotation axis [x,y,z]… exactly 3 items
`rotate.origin`	`number[]`	the point the axis passes through, in mm — th… exactly 3 items
`suppressed` optional	`boolean`	true = not built
`translate` optional	`number[]`	[x,y,z] mm exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_delete_face` destructive Delete face

Remove one face — re-cap the opening, or heal it by extending the neighbours.

Full description

Retires of. Call cad_help({tool:"cad_delete_face"}) for the rest.

Argument	Type	Meaning & bounds
`faceId` required	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`extend` optional	`boolean`	—
`heal` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sheet_fold` write Sheet fold

Sheet-metal part as ONE folded body — a constant-thickness strip with a base flange and a train of bends — with the developed FLAT PATTERN reported alongside the solid.

Full description

Call cad_help({tool:"cad_sheet_fold"}) for the rest.

Argument	Type	Meaning & bounds
`baseFlange` required	`number`	— > 0
`bends` required	`object[]`	the bends in order from the… ≥ 1 items
`thickness` required	`number`	— > 0
`width` required	`number`	— > 0
`bendTable` optional	`object`	a shop bend table: looked u…
`bendTable.entries`	`object[]`	rows keyed by… ≥ 1 items
`bendTable.material`	`string`	the material this table is…
`bendTable.name`	`string`	a label for this table…
`bendTable.thickness`	`number`	the stock thickness this ta… > 0
`bendTable.tolerance`	`number`	mm band the part’s thickn… > 0
`document` optional	`string`	handle or "new" length ≥ 1
`gauge` optional	`number`	a stocked gauge number… > 0
`kFactor` optional	`number`	K-factor — the neutral ax… > 0 · ≤ 0.5
`keepFailed` optional	`boolean`	—
`material` optional	`string`	— length ≥ 1
`params` optional	`object`	overrides for the gate's pa…
`process` optional	`string`	which shop's bend rule pack… length ≥ 1
`strict` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`thicknessTolerance` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sheet_box` write Sheet box

Sheet-metal BOX as ONE folded body — a rectangular base with walls folded up on all four edges, corner-notched, with the developed FLAT PATTERN reported per axis.

Full description

A chassis, tray or lid as ONE watertight solid instead of a shell plus a butt-jointed ring. Call cad_help({tool:"cad_sheet_box"}) for the rest.

Argument	Type	Meaning & bounds
`base` required	`object`	the rectangular b…
`base.length`	`number`	base panel length… > 0
`base.width`	`number`	base panel width… > 0
`flanges` required	`object`	the walls, keyed… ≥ 1 keys
`flanges.e`	`object`	the east (+X) wall
`flanges.n`	`object`	the north (+Y) wall
`flanges.s`	`object`	the south (−Y)…
`flanges.w`	`object`	the west (−X) wall
`thickness` required	`number`	— > 0
`bendTable` optional	`object`	a shop bend table…
`bendTable.entries`	`object[]`	rows keyed by… ≥ 1 items
`bendTable.material`	`string`	the material this…
`bendTable.name`	`string`	a label for this…
`bendTable.thickness`	`number`	the stock thickne… > 0
`bendTable.tolerance`	`number`	mm band the part… > 0
`document` optional	`string`	handle or "new" length ≥ 1
`gauge` optional	`number`	a stocked gauge n… > 0
`kFactor` optional	`number`	K-factor — the… > 0 · ≤ 0.5
`keepFailed` optional	`boolean`	—
`material` optional	`string`	— length ≥ 1
`notch` optional	`object`	how much clearanc…
`notch.gap`	`number`	extra corner reli… ≥ 0
`notch.placement`	`enum`	gap measured from one of "tangent", "intersection"
`notch.shape`	`enum`	corner relief shape one of "round", "square", "tear", "trimToBend", "linearWeld", "arcWeld", "laserWeld"
`params` optional	`object`	overrides for the…
`process` optional	`string`	which shop's bend… length ≥ 1
`strict` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`thicknessTolerance` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_offset_faces` destructive Offset region (offset a face set)

Direct edit: OFFSET REGION — offset a SET of faces together by one distance, re-trimming everything around them.

Full description

Call cad_help({tool:"cad_offset_faces"}) for the rest.

Argument	Type	Meaning & bounds
`distance` required	`number`	—
`faces` required	`array \| object \| string`	a face selection: a raw face id, a declarative…
`of` required	`string`	A body handle returned by an earlier modeling-t… length ≥ 1
`check` optional	`enum`	which ops/check tier runs on the moved body. one of "none", "local", "full"
`document` optional	`string`	A session document handle returned by an earlie… length ≥ 1
`keepFailed` optional	`boolean`	—
`propagate` optional	`enum`	which faces ride along with the set. one of "tangent", "none"
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built…
`tangentDeg` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_replace_face` destructive Replace face

Direct edit: REPLACE FACE — swap one face's surface for another plane/cylinder (or another face's surface) and re-trim its neighbours.

Full description

Call cad_help({tool:"cad_replace_face"}) for the rest.

Argument	Type	Meaning & bounds
`faceId` required	`object \| string`	exactly ONE face: a raw STEP face id…
`of` required	`string`	A body handle returned by an earlier modeling-t… length ≥ 1
`check` optional	`enum`	which ops/check tier runs on the moved body. one of "none", "local", "full"
`document` optional	`string`	A session document handle returned by an earlie… length ≥ 1
`keepFailed` optional	`boolean`	—
`offset` optional	`number`	—
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built…
`surface` optional	`object`	the explicit replacement surface: a plane { kin…
`withFace` optional	`object \| string`	exactly ONE face: a raw STEP face id…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_face_region` destructive Face region

Direct edit: copy, pattern or cut a boss/pocket face region.

Full description

Call cad_help({tool:"cad_face_region"}) for the rest.

Argument	Type	Meaning & bounds
`faces` required	`array \| object \| string`	a face selection: a raw face id, a declarative…
`mode` required	`enum`	"copy" pastes the region once under `translate`… one of "copy", "pattern", "cut"
`of` required	`string`	A body handle returned by an earlier modeling-t… length ≥ 1
`count` optional	`integer`	an integer >= 2 ≥ 2
`document` optional	`string`	A session document handle returned by an earlie… length ≥ 1
`keepFailed` optional	`boolean`	—
`rotate` optional	`object`	a rotation, given EITHER as the Euler triple {…
`rotate.angle`	`number`	rotation angle about `axis`, radians
`rotate.axis`	`number[]`	rotation axis [x,y,z] (need not be unit length)… exactly 3 items
`rotate.center`	`number[]`	rotation centre [x,y,z] in mm — default [0,0… exactly 3 items
`rotate.rx`	`number`	rotation about the world +X axis, radians
`rotate.ry`	`number`	rotation about the world +Y axis, radians
`rotate.rz`	`number`	rotation about the world +Z axis, radians
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built…
`target` optional	`string`	A body handle returned by an earlier modeling-t… length ≥ 1
`translate` optional	`number[]`	[x, y, z] in millimetres exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_defeature` destructive Defeature (simplify by detail size)

Defeature / simplify by detail size: remove every hole, boss, fillet and chamfer under a size, or suppress the blend networks of the given faces.

Full description

Give at least one size threshold in mm, or faces. Call cad_help({tool:"cad_defeature"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-t… length ≥ 1
`blendNetworks` optional	`boolean`	—
`bossDiameter` optional	`number`	— > 0
`chamferDistance` optional	`number`	— > 0
`document` optional	`string`	A session document handle returned by an earlie… length ≥ 1
`faces` optional	`array \| object \| string`	a face selection: a raw face id, a declarative…
`filletRadius` optional	`number`	— > 0
`holeDiameter` optional	`number`	— > 0
`keepFailed` optional	`boolean`	—
`maxPasses` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sheet_feature` write Sheet feature

Sheet-metal part said the way a DRAWING says it: flange, hem, jog, sketched bend, tab, cross-break, vent, bend relief, closed corner -- each turned into the bends ops/sheetMetal folds, with the developed blank reported alongside.

Full description

cad_sheet_fold speaks the machine's language -- "bend -74.6 degrees over r2, then a flat of 11.3". Call cad_help({tool:"cad_sheet_feature"}) for the rest.

Argument	Type	Meaning & bounds
`baseFlange` required	`number`	— > 0
`features` required	`object[]`	the features in the order t… ≥ 1 items
`thickness` required	`number`	— > 0
`width` required	`number`	— > 0
`cuts` optional	`object[]`	holes and cutouts in the BL…
`document` optional	`string`	handle or "new" length ≥ 1
`kFactor` optional	`number`	K-factor — the neutral ax… > 0 · ≤ 0.5
`keepFailed` optional	`boolean`	—
`name` optional	`string`	— length ≥ 1
`output` optional	`enum`	"folded" (default) publishe… one of "folded", "blank"
`params` optional	`object`	overrides for the gate's pa…
`process` optional	`string`	which shop's bend rule pack… length ≥ 1
`strict` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sheet_miter` write Sheet miter

A flange run along a CHAIN of base edges with the corners mitred: every corner's miter angle and measured gap, and the exact flat pattern leg by leg.

Full description

A report, not a body -- a mitred run has a bend axis per leg and no two of them are parallel. Call cad_help({tool:"cad_sheet_miter"}) for the rest.

Argument	Type	Meaning & bounds
`height` required	`number`	— > 0
`path` required	`number[][]`	open [x,y] polyline ≥ 2 items
`thickness` required	`number`	— > 0
`angle` optional	`number`	—
`closed` optional	`boolean`	—
`document` optional	`string`	handle or "new" length ≥ 1
`gap` optional	`number`	mm, >= 0 ≥ 0
`gapFrom` optional	`enum`	"corner" (default) reads `gap` as the CLEAR DIS… one of "corner", "trim"
`heightFrom` optional	`enum`	where a flange height is measured from: "tangen… one of "tangent", "outer", "mouldLine", "inside"
`kFactor` optional	`number`	K-factor — the neutral axis position as a fra… > 0 · ≤ 0.5
`keepFailed` optional	`boolean`	—
`radius` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_sheet_convert` write Sheet convert

Solid mould to sheet metal: flat blank, rips, unfold, cuts.

Full description

Call cad_help({tool:"cad_sheet_convert"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`thickness` required	`number`	— > 0
`autoRip` optional	`boolean`	—
`bendTable` optional	`object`	a shop bend table: looked up per bend by (inside radius, angle) ahead of the published R/T table, and behind a gauge table and any per-bend bendAllowance/bendDeduction/kFactor
`bendTable.entries`	`object[]`	rows keyed by (radius, angle); at least one of allowance/deduction/kFactor per row ≥ 1 items
`bendTable.material`	`string`	the material this table is FOR — reported, not enforced
`bendTable.name`	`string`	a label for this table, e.g. the shop or brake it came from — carried onto every bend it drives (flatPattern.bends[].source) and the flat-DXF bend schedule
`bendTable.thickness`	`number`	the stock thickness this table is FOR, mm. When given, the part’s own thickness must match within `tolerance` (or the op’s thicknessTolerance) or the op refuses — a table applied to the wrong stock gives a wrong deduction. > 0
`bendTable.tolerance`	`number`	mm band the part’s thickness is allowed to deviate from `thickness` by; default 0.1 mm > 0
`cuts` optional	`number[][][]`	closed cut polygons in FLAT-PATTERN coordinates (mm; the frame report.sheetConvert.flat.bbox and bends[].flat are in), subtracted from the blank and reported on the folded part ≥ 1 items · ≤ 64 items
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`fixedFace` optional	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`kFactor` optional	`number`	K-factor — the neutral axis position as a fraction of thickness from the INSIDE surface, in (0, 0.5]. Omit for the published air-bending R/T table (mild steel). > 0 · ≤ 0.5
`keepFailed` optional	`boolean`	—
`open` optional	`array \| object \| string`	a face selection: a raw face id, a declarative selector object, or an array mixing both (an empty array selects nothing, which is meaningful for shell's "open")
`radius` optional	`number`	— > 0
`ripGap` optional	`number`	a length in mm, zero or greater ≥ 0
`rips` optional	`object \| string[]`	edges to RIP instead of bend: a raw edge id, an edge selector, or { edge, overlap } where `overlap` names the face that runs to the mould edge (the other butts against it); default overlap: the face nearer the fixed face ≥ 1 items · ≤ 256 items
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`unfold` optional	`array \| object \| string`	a edge selection: a raw edge id, a declarative selector object, or an array mixing both

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_corner_relief` write Corner relief

DOGBONE / T-BONE relief on an inside corner — the over-cut that lets a square mating part seat in a pocket a round cutter made.

Full description

NOT a fillet. A round router bit cannot cut a square internal corner: whatever the drawing says, the corner comes out at the bit radius and a square peg will not seat in it. Call cad_help({tool:"cad_corner_relief"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`clearance` optional	`number`	mm, >= 0 ≥ 0
`corners` optional	`object[]`	the inside corners to relieve, each as a vertex… ≥ 1 items
`depth` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`meshFallback` optional	`boolean`	—
`pocket` optional	`object`	an axis-aligned rectangle in the XY (tool) plan…
`pocket.max`	`number[]`	upper corner [x, y], mm exactly 2 items
`pocket.min`	`number[]`	lower corner [x, y], mm exactly 2 items
`style` optional	`enum`	relief style — "dogbone" puts ONE bit-radius… one of "dogbone", "tbone"
`suppressed` optional	`boolean`	true = not built
`through` optional	`boolean`	—
`toolDia` optional	`number`	— > 0
`walls` optional	`enum`	T-bone only: which wall(s) carry the relief. one of "both", "a", "b"

Exactly one of these argument shapes: corners — or — pocket. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_enclosure` write Electronics enclosure from an envelope

Builds a box ENCLOSURE (base + lid) around a board envelope (envelope.json + config): port cut-outs from the max-plug keep-outs, process mounts (fdm heat-set boss, sheet PEM standoff, moulded drafted boss, cnc tapped boss), snap/screw/tray lid, vents sized to an open area.

Full description

Call cad_help({tool:"cad_enclosure"}) for the rest.

Argument	Type	Meaning & bounds
`envelope` required	`string`	envelope.json path, or sample:<name>… length ≥ 1
`build` optional	`boolean`	false: plan + box audit only, no kernel.
`clearance` optional	`number`	Part-to-enclosure clearance, mm. ≥ 0
`config` optional	`string`	Envelope config name. Default: the first.
`detail` optional	`enum`	full adds checks, design, sources. one of "summary", "full"
`extras` optional	`object[]`	Extra material blocks / cuts (audited).
`includeOps` optional	`boolean`	Return the executor ops (cad_build_plan).
`lid` optional	`enum`	Lid kind. Default per process. one of "snap", "screw", "tray"
`material` optional	`string`	Material (snap strain). e.g. PETG, PLA.
`mounts` optional	`enum`	Mount kind. Default per process. one of "standoff", "boss", "pem"
`out` optional	`string`	STEP output path.
`ports` optional	`string[]`	Port ids to open. Default: edge ports.
`process` optional	`enum`	Manufacturing process. Default fdm. one of "fdm", "sheet", "molded", "cnc"
`requirements` optional	`string`	requirements.json path (standards).
`vents` optional	`object \| boolean`	Vent spec, or false for none.
`wall` optional	`number`	Wall / sheet thickness, mm. > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Freeform surfacing · 17

Surfaces built from curves rather than from a profile and a distance: boundary and net surfaces, hole fills that meet their neighbours tangentially, untrim and extend, and the curve fit that feeds them all. These publish sheet bodies - thicken one, or stitch a set of them, to get a solid.

`cad_boundary_surface` write Boundary surface

Build a sheet body inside a closed loop of 3 or more curves.

Full description

Four curves give one bilinearly blended COONS patch; any other count gives ONE sheet of N faces — N Coons sub-patches meeting at an interior centre, G1 across the shared spokes. Sides may be listed in any order and any direction — they are chained head to tail for you. Call cad_help({tool:"cad_boundary_surface"}) for the rest.

Argument	Type	Meaning & bounds
`boundaries` required	`array \| object \| string[]`	>=2 curves, chained ≥ 2 items
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`reparam` optional	`enum`	curve timing one of "natural", "arclength"
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_ruled_surface` write Ruled surface

Build a RULED sheet — straight lines between two curves, or off one curve along a direction.

Full description

SolidWorks / NX "Ruled Surface", ACIS api_make_ruled: the mould-maker's surface. Call cad_help({tool:"cad_ruled_surface"}) for the rest.

Argument	Type	Meaning & bounds
`curve` optional	`array \| object \| string`	id, polyline or spec
`curves` optional	`array \| object \| string[]`	>=2 curves, chained ≥ 2 items
`direction` optional	`number[]`	[x,y,z] mm exactly 3 items
`distance` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`flip` optional	`boolean \| string`	pair the second curve reversed (true), as given…
`keepFailed` optional	`boolean`	—
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_offset_surface` write Offset surface

Copy one B-spline face at a distance along its normal, as a new SHEET body.

Full description

Call cad_help({tool:"cad_offset_surface"}) for the rest.

Argument	Type	Meaning & bounds
`distance` required	`number`	—
`face` required	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`keepFailed` optional	`boolean`	—
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_flatten_surface` write Flatten surface

Develop one curved B-spline face into a FLAT pattern (a planar sheet), with the stretch it costs measured.

Full description

SolidWorks "Surface Flatten" / NX "Flatten & Form": the cut pattern for a gasket, a composite ply, sheet trim or upholstery. Call cad_help({tool:"cad_flatten_surface"}) for the rest.

Argument	Type	Meaning & bounds
`face` required	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`keepFailed` optional	`boolean`	—
`plane` optional	`object \| string`	a sketch/inline-profile plane: either an explicit frame object or the id string of an earlier datum_plane
`samples` optional	`integer`	— ≥ 1
`strainTol` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mutual_trim` write Mutual trim

Trim two sheets against each other and keep one piece of each.

Full description

Call cad_help({tool:"cad_mutual_trim"}) for the rest.

Argument	Type	Meaning & bounds
`keep` required	`object[]`	per sheet, the piece to keep: { point } or { side } exactly 2 items
`sheets` required	`string[]`	the two sheets [a, b] exactly 2 items
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`keepFailed` optional	`boolean`	—
`result` optional	`enum`	"one" sewn sheet (default) or "two" (<id>, <id>#1) one of "one", "two"
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_net_surface` write Net surface

Build a sheet body through a NETWORK of curves running in two directions.

Full description

The Gordon surface — "Through Curve Mesh" in NX, "Boundary Surface" with both direction sets filled in, api_net_surface in ACIS. Call cad_help({tool:"cad_net_surface"}) for the rest.

Argument	Type	Meaning & bounds
`uCurves` required	`array \| object \| string[]`	>=2 curves, chained ≥ 2 items
`vCurves` required	`array \| object \| string[]`	>=2 curves, chained ≥ 2 items
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`reparam` optional	`enum`	curve timing one of "natural", "arclength"
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fill_patch` write Fill patch

Fill a closed ring of boundary curves, meeting the neighbouring faces to G0/G1/G2 — and optionally sew the patch into the body.

Full description

The hole-patching operator. Call cad_help({tool:"cad_fill_patch"}) for the rest.

Argument	Type	Meaning & bounds
`boundaries` required	`array \| object \| string \| object[]`	the closed ring of boundary sides to fill (>= 3). ≥ 3 items
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`into` optional	`array \| string`	the body (or bodies) to sew the finished patch…
`keepFailed` optional	`boolean`	—
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = not built
`tangentScale` optional	`number`	— > 0
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_untrim_face` write Untrim face

Recover the full underlying surface behind a trimmed face, as a sheet body.

Full description

Publishes the face's own supporting surface over its NATURAL rectangular (u,v) domain — the knot-vector span of the B-spline patch — discarding whatever trim the face currently carries, and reports natural.uRange/vRange/corners. Call cad_help({tool:"cad_untrim_face"}) for the rest.

Argument	Type	Meaning & bounds
`face` required	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`keepFailed` optional	`boolean`	—
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_extend_face` write Extend face

Continue a face past its own edge by a distance, as a sheet body.

Full description

The natural (analytic) continuation of the surface, NOT a linear ramp off the end: the patch's own polynomial is evaluated UNCLAMPED past its knot domain, which is what makes an extended fillet or loft face still lie on the shape it came from. Call cad_help({tool:"cad_extend_face"}) for the rest.

Argument	Type	Meaning & bounds
`distance` required	`number`	— > 0
`face` required	`object \| string`	exactly ONE face: a raw STEP face id (from cad_body_topology), a declarative face selector object (surface, normal, radius, area, at, bbox, createdBy, largest/smallest, topmost/bottommost, extreme, tolDeg), { ref } or { normal, through }
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`degree` optional	`integer`	— ≥ 1
`direction` optional	`enum`	which parametric direction of the face to extend ("u" default) one of "u", "v"
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`end` optional	`enum`	which end(s) of that direction to extend ("both" default) one of "start", "end", "both"
`keepFailed` optional	`boolean`	—
`mode` optional	`enum`	"distance" (default) reads "distance" as millimetres; "percent" reads it as a percentage of the face's own current length in that direction one of "distance", "percent"
`samples` optional	`integer`	— ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fit_curve` write Fit a curve through points

Fit a NURBS curve through a list of 3D points.

Full description

Piegl & Tiller A9.1 global interpolation: the curve passes through EVERY point exactly (reported deviation is 0), centripetally parameterised. Call cad_help({tool:"cad_fit_curve"}) for the rest.

Argument	Type	Meaning & bounds
`points` required	`number[][]`	ordered [x,y,z] pts ≥ 2 items
`closed` optional	`boolean`	—
`continuity` optional	`enum`	continuity inside the fitted curve/face: simple… one of "G2", "G3", "G4"
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`minSpan` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fit_surface` write Fit a surface through points

Fit a NURBS surface through a rectangular grid of points, or least-squares through a scattered cloud.

Full description

Two fits in one verb, chosen by which data you give. Call cad_help({tool:"cad_fit_surface"}) for the rest.

Argument	Type	Meaning & bounds
`continuity` optional	`enum`	continuity inside the fitted curve/face: simple… one of "G2", "G3", "G4"
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`grid` optional	`number[][][]`	a RECTANGULAR grid of points to interpolate: gr… ≥ 2 items
`keepFailed` optional	`boolean`	—
`minSpan` optional	`number`	— > 0
`nu` optional	`integer`	— ≥ 1
`nv` optional	`integer`	— ≥ 1
`points` optional	`number[][]`	ordered [x,y,z] pts ≥ 2 items
`samples` optional	`integer`	— ≥ 1
`smoothing` optional	`number`	mm, >= 0 ≥ 0
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0
`trim` optional	`number[][][]`	closed loops in the FITTED SURFACE's own parame… ≥ 1 items
`trimSamples` optional	`integer`	— ≥ 1
`trimTol` optional	`number`	— > 0
`uDegree` optional	`integer`	— ≥ 1
`vDegree` optional	`integer`	— ≥ 1

Exactly one of these argument shapes: grid — or — points. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mesh_to_brep` write Mesh to B-rep

Rebuild a B-rep body from an imported triangle mesh: segment, recognise the analytic faces, fit the rest, sew.

Full description

of names that import. The mesh is segmented, recognised as plane/cylinder/cone/sphere/torus or fit as a B-spline, and sewn (mixed) into one solid when possible. Call cad_help({tool:"cad_mesh_to_brep"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`analyticFirst` optional	`boolean`	—
`blends` optional	`enum`	what mesh_to_brep does with a band it RECOGNISED as a fillet or a chamfer (a constant-radius cylinder/torus region tangent to exactly two supports; a narrow inclined planar strip between two supports meeting it at 30-60 degrees). "keep" authors the fitted band as a trimmed face — correct geometry, but a DUMB band: nothing on the body says "r=4 fillet on this edge". "refit" rebuilds the body SHARP (the two supports intersected directly, so their loops re-close on one sharp edge) and re-applies the kernel's own fillet/chamfer at the MEASURED radius/setback, which is an EDITABLE blend cad_param_list and cad_design_review both read back. "auto" (the default) builds BOTH and ships whichever comes out closer to the mesh on ops/meshCompare.js's normalised Hausdorff distance, a tie going to the refit; the report carries both numbers, every recognised blend with its measured radius/setback and tangency, and the kernel's own reason code for any blend it refused one of "keep", "refit", "auto"
`budget` optional	`object`	when converge stops looking, whether or not the target was met. The report always says which of the two ran out ("stoppedBecause":"budget") and the best body found so far is still published
`budget.candidates`	`integer`	how many candidates may be built, default 12. "candidates": 1 is the honest way to ask for exactly the first rung with its numbers measured ≥ 1
`budget.ms`	`number`	wall-clock limit in milliseconds, default 60000. Checked BETWEEN candidates — a candidate that has started always finishes, because a measurement cut half way through is not a measurement > 0
`compare` optional	`boolean`	—
`componentFineRetry` optional	`boolean`	—
`componentFineRetryBudgetMs` optional	`number`	—
`componentVerify` optional	`boolean`	—
`components` optional	`boolean`	—
`converge` optional	`boolean`	—
`cornerConcurrency` optional	`boolean`	—
`cuts` optional	`object[]`	exact primitives for route "members": as "interfaces" they are UNITED as given (pads, feet, bosses, hubs — the faces the part bolts to); as "cuts" they are SUBTRACTED after every union (bores, clearance holes). "kind" is required
`decimateBudget` optional	`integer`	— ≥ 1
`degree` optional	`integer`	— ≥ 1
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`featureAngle` optional	`number`	— > 0
`heal` optional	`boolean`	—
`healComponents` optional	`boolean`	—
`hints` optional	`object[]`	what you SAW, as a steer for the deterministic solver: [{region, kind}] (this region is really a cylinder — tried first, accepted at 2x tolerance), [{region, blendRadius}] (refit this fillet at r), [{axis:[x,y,z]}] (the part is extruded/revolved about this), [{merge:[i,j]}] (those two regions are ONE face). Region indices are report.faces[].index from the PREVIOUS run — faces[] carries centroid and bbox so you can map a coloured stripe in a mesh_compare diff PNG to a region. A hint LOOSENS, never forces: report.hints.rejected names any that missed, with the deviation measured. ≥ 1 items
`interfaces` optional	`object[]`	exact primitives for route "members": as "interfaces" they are UNITED as given (pads, feet, bosses, hubs — the faces the part bolts to); as "cuts" they are SUBTRACTED after every union (bores, clearance holes). "kind" is required
`jobMode` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`maxRegions` optional	`integer`	— ≥ 1
`members` optional	`object`	route "members"'s own tuning, forwarded verbatim to ops/meshMembers.js (its DEFAULTS): voxelMm (grid step, default bbox diagonal / 200 clamped to 0.4..2), coverMax (drop a strut/plate with >= this fraction inside plates/interfaces, 0.6), strutRadius ("uniform" — one radius per frame, exact nodes — or "measured"), fitVolume / maxGrow, gussets ("bridge" \| "all" \| "none"), jointBalls, minStrutRadius, autoInterfaces, autoSnapMm, budgetMs (per boolean in the emitted document, 60000). Every member is optional; an unknown one is ignored by the route
`members.fullPlan`	`boolean`	keep the executor document on members.plan VERBATIM in the tool reply. By default the plan is compacted to an op census (count by op kind, resultId) so a many-strut frame fits the reply budget; the full document is what you re-run through cad_build_plan after editing a radius or a bore
`minComponentTriangles` optional	`integer`	— ≥ 1
`mixed` optional	`boolean`	—
`nu` optional	`integer`	— ≥ 1
`nv` optional	`integer`	— ≥ 1
`preflight` optional	`boolean`	—
`preflightBudgetMs` optional	`number`	— > 0
`quad` optional	`object`	route "quad"'s tuning: layout ("auto" = strut skeleton, else the general disk-partition layout; "skeleton"; "general"), tolerance (mm, drives the adaptive split), targetMm (region radius, default diagonal / 9), regions, spans, maxRefine (adaptive-split rounds, 3), and the switches below
`quad.analytic`	`enum`	— one of "off", "hints", "auto"
`quad.analyticAngleDeg`	`number`	— ≥ 0 · ≤ 90
`quad.analyticBandMm`	`number`	— ≥ 0
`quad.analyticMinAreaFrac`	`number`	— ≥ 0 · ≤ 1
`quad.analyticMinTris`	`integer`	— ≥ 1
`quad.analyticTol`	`number`	— > 0
`quad.compactness`	`number`	— ≥ 0 · ≤ 100
`quad.cornerTwist`	`number`	— ≥ 0 · ≤ 1000000
`quad.creaseDeg`	`number`	— ≥ 0 · ≤ 180
`quad.cubeScale`	`number`	— > 0 · ≤ 10
`quad.dataTangentWeight`	`number`	— ≥ 0 · ≤ 1
`quad.edgeChord`	`number`	— ≥ 0 · ≤ 1
`quad.edgeSamples`	`integer`	— ≥ 4 · ≤ 400
`quad.fanGapMinDeg`	`number`	— ≥ 0 · ≤ 60
`quad.fitIters`	`integer`	— ≥ 0 · ≤ 200
`quad.foldGrid`	`integer`	— ≥ 4 · ≤ 64
`quad.g1Blend`	`boolean`	—
`quad.g1Joint`	`boolean`	—
`quad.g1JointEndWeight`	`number`	— ≥ 0 · ≤ 1
`quad.g1JointWeight`	`number`	— ≥ 0 · ≤ 1000000000
`quad.g1Planes`	`boolean`	—
`quad.g1Polish`	`integer`	— ≥ 0 · ≤ 8
`quad.g1PolishBand`	`integer`	— ≥ 1 · ≤ 3
`quad.g1PolishDeg`	`number`	— ≥ 0 · ≤ 90
`quad.g1PolishIters`	`integer`	— ≥ 1 · ≤ 50
`quad.g1PolishStations`	`integer`	— ≥ 4 · ≤ 64
`quad.g1PolishWeight`	`number`	— ≥ 0 · ≤ 1000000
`quad.layout`	`enum`	— one of "auto", "skeleton", "general"
`quad.lloydIters`	`integer`	— ≥ 0 · ≤ 100
`quad.maxArcs`	`integer`	— ≥ 0 · ≤ 64
`quad.maxCornerDeg`	`number`	— ≥ 0 · ≤ 360
`quad.maxRefine`	`integer`	— ≥ 0 · ≤ 12
`quad.maxRegions`	`integer`	— ≥ 1 · ≤ 5000
`quad.maxSpans`	`integer`	— ≥ 1 · ≤ 16
`quad.maxSplitPerRound`	`integer`	— ≥ 1 · ≤ 1000
`quad.mergeMm`	`number`	— ≥ 0
`quad.minFaceCos`	`number`	— ≥ -1 · ≤ 1
`quad.minStrutMm`	`number`	— ≥ 0
`quad.normalRadiusMm`	`number`	— > 0
`quad.paramCorrect`	`integer`	— ≥ 0 · ≤ 8
`quad.patchSamples`	`integer`	— ≥ 4 · ≤ 200
`quad.regions`	`integer`	— ≥ 1 · ≤ 2000
`quad.sectorCreaseWeight`	`number`	— ≥ 0 · ≤ 1000000
`quad.sectorPlanes`	`boolean`	—
`quad.skeleton`	`object`	—
`quad.smooth`	`number`	— ≥ 0 · ≤ 1
`quad.smoothTwist`	`number`	— ≥ 0 · ≤ 1000000
`quad.spanGrow`	`number`	— ≥ 1 · ≤ 4
`quad.spanRefine`	`integer`	— ≥ 0 · ≤ 12
`quad.spans`	`integer`	— ≥ 1 · ≤ 16
`quad.splitLowValence`	`boolean`	—
`quad.straighten`	`integer`	— ≥ 0 · ≤ 20
`quad.targetMm`	`number`	— > 0
`quad.tolerance`	`number`	— > 0
`quad.twistPlaneWeight`	`number`	— ≥ 0 · ≤ 1000000000
`quad.untangleFans`	`boolean`	—
`quad.vertexG1`	`boolean`	—
`quad.voxelMm`	`number`	— > 0
`quad.wallSpans`	`integer`	— ≥ 1 · ≤ 32
`recipe` optional	`boolean`	—
`route` optional	`enum`	which rebuild runs. "auto" (default) is the surface ladder — analytic, polyhedral, recipe, mixed, spline — that asks "which SURFACE is this region". "members" asks "which MEMBER is this" instead: the mesh is voxelised and rebuilt as structural members — extruded plates, one-radius strut frames with exact cylinder-cylinder nodes, square tabs into bosses, planar gussets — united around the exact "interfaces" given, with "cuts" subtracted LAST so every bore is the exact cylinder asked for. It is the route for a topology-optimised or lattice part, whose organic skin no surface route can close as one body; the result is one watertight solid of planes, cylinders and spheres only, and the executor DOCUMENT that built it plus the feature tree ({plates, struts, joints, balls, tabs, gussets, interfaces, cuts}) and voxel statistics ride on the result's "members" (plan, stats, body). With neither "interfaces" nor "cuts", the mesh's own cylinder regions are read as bores and bosses (members.autoInterfaces). one of "auto", "members", "quad"
`samples` optional	`integer`	— ≥ 1
`segmentation` optional	`enum`	how the triangles are grouped into regions before recognition. "fit" (default) grows each region while a MEASURED fit through its own points stays within "tolerance" — planes first, then cylinders/cones/spheres/tori, then whatever is left by the crease rule — which is the only way a TANGENT boundary is found: a fillet is G1 to both of its supports, so no edge on either side of it is a crease and the plane, the fillet and the next plane come back as ONE region that fits nothing. "dihedral" is CADSF-958's crease flood fill, unchanged, for a caller who wants exactly the behaviour that shipped. The report carries "segmentation.mode" and "segmentation.byKind" so you can see which regions the segmenter proposed as what one of "fit", "dihedral"
`smoothing` optional	`number`	a length in mm, zero or greater ≥ 0
`ssi` optional	`boolean`	—
`stitchTol` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`target` optional	`object`	what "good enough" means for converge — the loop stops as soon as ONE candidate meets every member of this at once. Every member is optional and takes the default named below, so "converge": true on its own is already a complete ask. Whether each one was met, for the body that actually shipped, comes back on the report as "converge.met"
`target.minIou2d`	`number`	the WORST cutting-plane station's 2-D section overlap (even-odd filled, so holes count). Default 0.99 — ops/meshCompare.js's own DEFAULT_SECTION_TARGETS, the number that sees INSIDE the part ≥ 0 · ≤ 1
`target.minSilhouetteIoU`	`number`	the WORST of the 8 canonical views' silhouette IoU. Default 0.995. Only evaluated for candidates that already met every numeric target — rendering is earned, not spent up front — and not at all when rendering is off ≥ 0 · ≤ 1
`target.normalisedHausdorff`	`number`	the TWO-SIDED Hausdorff distance between mesh and body as a fraction of the mesh's bounding-box diagonal. Default 2 x tolerance / diagonal — i.e. the plan's "within two tolerances everywhere" rule, expressed scale-free ≥ 0
`target.volumeErrorPct`	`number`	the allowed \|volume error\| in per cent, body against the closed mesh. Default 0.5 ≥ 0
`target.worstAreaErrorPct`	`number`	the worst cutting-plane station's signed-area error, per cent. Default 1.0 ≥ 0
`tolerance` optional	`number`	— > 0
`verify` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mesh_section` write Mesh section

Slice an imported mesh into closed section polylines and segment each into line / arc / B-spline spans.

Full description

Publishes NO body — a section is curves. of names an import that published a mesh. Call cad_help({tool:"cad_mesh_section"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`atRegions` optional	`boolean`	—
`axis` optional	`array \| string`	the axis a stack of sections runs along…
`cornerAngleDeg` optional	`number`	— > 0
`count` optional	`integer`	— ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`featureAngle` optional	`number`	— > 0
`fit` optional	`boolean`	—
`fitTol` optional	`number`	— > 0
`from` optional	`number`	—
`inset` optional	`number`	mm, >= 0 ≥ 0
`keepFailed` optional	`boolean`	—
`minSpanPoints` optional	`integer`	— ≥ 1
`plane` optional	`object`	one cutting plane: { origin: [x,y,z], normal: […
`plane.normal`	`number[]`	the plane's normal, [x, y, z]… exactly 3 items
`plane.origin`	`number[]`	a point ON the cutting plane, [x, y, z] in mill… exactly 3 items
`plane.xAxis`	`number[]`	OPTIONAL: which in-plane direction the section'… exactly 3 items
`points` optional	`boolean`	—
`spacing` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built
`to` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mesh_compare` read Compare mesh to body

Measure a solid against the mesh it was reconstructed from, or any mesh — the SAME engine cad_mesh_to_brep's own compare:true calls, exposed on its own.

Full description

Call cad_help({tool:"cad_mesh_compare"}) for the rest.

Argument	Type	Meaning & bounds
`body` required	`string`	The SOLID to measure — typically the body cad… length ≥ 1
`of` required	`string`	The MESH to compare against — an .stl/.obj/.3… length ≥ 1
`imageSize` optional	`integer`	— ≥ 1
`outDir` optional	`string`	Directory rendered PNGs are written under… length ≥ 1
`overlay` optional	`boolean`	Also write an interactive HTML viewer showing t…
`sections` optional	`boolean \| object`	false to skip the cutting-plane comparison, or…
`tolerance` optional	`number`	— > 0
`views` optional	`array \| boolean`	true (all 8 canonical views), false…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_surface_analysis` read Surface analysis (class A)

Read-only class-A surface analysis of bodies or sheets.

Full description

continuity: G0 gap mm, G1 normal deg, G2 jump 1/mm per shared edge, sheet edge pair or in-face crease; PASS/FAIL at 0.001 mm / 0.2 deg. knots: B-spline face interior knot lines classed G0-G4 (Parasolid needs G1). curvature: per-face, min radius, comb. zebra: stripe jump per join. deviation: distance to ref. draft: face angle vs pull.

Argument	Type	Meaning & bounds
`kind` required	`enum`	— one of "continuity", "curvature", "zebra", "deviation", "draft", "knots"
`of` required	`string \| array`	Body/sheet handle(s); several pair their edges. ≥ 1 items · ≤ 8 items
`chordTol` optional	`number`	Tessellation chord, mm. > 0
`comb` optional	`object`	curvature: comb on {edge} or {face, u\|v 0..1}.
`comb.edge`	`string`	—
`comb.face`	`string`	—
`comb.u`	`number`	— ≥ 0 · ≤ 1
`comb.v`	`number`	— ≥ 0 · ≤ 1
`edges` optional	`boolean`	knots: also grade shared edges.
`faces` optional	`string[]`	Only these face ids.
`field` optional	`boolean`	zebra: add the per-vertex stripe field.
`light` optional	`number[]`	zebra: light direction (default 1,1,1). exactly 3 items
`minDraft` optional	`number`	draft: floor, deg (default 1). ≥ 0
`pull` optional	`number[]`	draft: pull direction (default +Z). exactly 3 items
`ref` optional	`string`	deviation: reference body, sheet or mesh.
`samples` optional	`integer`	Samples per edge / comb (default 24). ≥ 4 · ≤ 200
`stripes` optional	`number`	zebra: stripe pairs per 180 deg (default 8). > 0
`target` optional	`enum`	knots: class to verify (default G2). one of "G1", "G2", "G3", "G4"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`comb` optional	`object`	—
`creases` optional	`any[]`	—
`edges` optional	`any[]`	—
`faces` optional	`any[]`	—
`field` optional	`object`	—
`kind` optional	`string`	—
`parasolid` optional	`object`	—
`summary` optional	`object`	—
`under` optional	`any[]`	—
`verdict` optional	`string`	—

`cad_crease_repair` destructive Crease repair

Repair the interior G1 creases Parasolid-based CAD splits on import: smooth the small ones, turn the rest into real edges.

Full description

Retires of (a solid or a sheet), publishes ONE body of the same kind. Call cad_help({tool:"cad_crease_repair"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`dryRun` optional	`boolean`	—
`faceBudget` optional	`integer`	a positive integer ≥ 1
`faces` optional	`string[]`	an array of raw STEP face id strings…
`keepFailed` optional	`boolean`	—
`mode` optional	`enum`	"auto" = smooth the creases within smoothTol an… one of "auto", "smooth", "split"
`smoothTol` optional	`number`	mm, >= 0 ≥ 0
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_shell_from_outline` write Shell from outline

Press a MOULDED SHELL from a plan outline, a rim-height profile, a dish and a thickness — one closed solid with tangent-continuous walls, optionally with its swivel base.

Full description

For a moulded shell — an Egg, a Swan, a Series 7 seat pan — do NOT loft 40 cross sections and do NOT sweep a thin rectangle. Call cad_help({tool:"cad_shell_from_outline"}) for the rest.

Argument	Type	Meaning & bounds
`dish` required	`number \| object`	how deep it dishes below the LOWEST rim point, and with what bowl / flare / profile shape
`outline` required	`array \| object`	the closed PLAN silhouette in mm, as [x, y] points; smoothed to a fair curve unless smooth:false
`rimHeight` required	`array \| number`	a number, or PERIODIC {t,z}
`thickness` required	`number`	INWARD from the OUTER face > 0
`base` optional	`boolean \| object`	also build the swivel base (arms + hub disc + column) as a SECOND body beside the shell
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`flare` optional	`number`	alias for dish.flare: the wall's lean from VERTICAL at the rim, in degrees > 0 · < 89
`g1TolDeg` optional	`number`	the tangent-continuity gate in degrees (default 1) — a bigger crease is refused by name > 0
`keepFailed` optional	`boolean`	—
`samples` optional	`integer`	fit grid per direction (default 17): higher fits closer and thickens slower ≥ 8 · ≤ 64
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`tol` optional	`number`	offset tolerance in mm (default 1e-3 of the plan diagonal); much tighter is much slower > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Booleans, transforms & patterns · 13

Combining and rearranging bodies: the three booleans, rigid transforms, mirroring and patterning, the splits that divide a body or a face, and the stitch that closes a shell back into a solid.

`cad_boolean_union` destructive Boolean union

Boolean union: base plus tool (A u B).

Full description

Exact on planes, cylinders, cones and spheres — support matrix below. For a boss on a planar face, prefer cad_pad (analytic, instant); union with cad_cylinder is exact there too, fillets or holes included (measured on a filleted, drilled 40x40x10 plate: 15 faces in 0.05-0.1 s). Call cad_help({tool:"cad_boolean_union"}) for the rest.

Argument	Type	Meaning & bounds
`allowMultiLump` optional	`boolean`	—
`analyticOnly` optional	`boolean`	—
`bodies` optional	`string[]`	non-empty strings ≥ 1 items
`budgetMs` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`fallback` optional	`object`	ladder opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`fuzzy` optional	`number`	—
`implicitFallback` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`keepInputs` optional	`boolean`	—
`meshFallback` optional	`boolean`	—
`mitre` optional	`boolean`	—
`of` optional	`string`	body handle length ≥ 1
`order` optional	`enum`	the order a multi-tool union folds its tools in. one of "input", "overlap", "many"
`suppressed` optional	`boolean`	true = not built
`tool` optional	`array \| string`	handle(s) or a group

Exactly one of these argument shapes: of + tool — or — bodies. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_boolean_subtract` destructive Boolean subtract

Boolean subtract: base minus tool (A - B).

Full description

Exact on planes, cylinders, cones, tori and axis-clipped spheres — support matrix below. Call cad_help({tool:"cad_boolean_subtract"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`tool` required	`array \| string`	handle(s) or a group
`allowMultiLump` optional	`boolean`	—
`budgetMs` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`fallback` optional	`object`	ladder opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`fuzzy` optional	`number`	—
`implicitFallback` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`keepInputs` optional	`boolean`	—
`meshFallback` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_boolean_intersect` destructive Boolean intersect

Boolean intersect: base and tool (A n B).

Full description

Exact for two axis-aligned boxes, a convex planar tool, and a ball clipped by a convex planar body on ANY number of axes — the rounded cube included — support matrix below. Call cad_help({tool:"cad_boolean_intersect"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`tool` required	`array \| string`	handle(s) or a group
`allowMultiLump` optional	`boolean`	—
`budgetMs` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`fallback` optional	`object`	ladder opt-in
`fallback.allowDegraded`	`boolean`	—
`fallback.allowTolerant`	`boolean`	—
`fallback.disable`	`string[]`	—
`fallback.maxRung`	`integer \| string`	—
`fuzzy` optional	`number`	—
`keepFailed` optional	`boolean`	—
`keepInputs` optional	`boolean`	—
`meshFallback` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_transform` write Transform

Rotate (any axis) and/or translate a solid — MOVES it by default.

Full description

Call cad_help({tool:"cad_transform"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`copy` optional	`boolean`	—
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`rotate` optional	`object`	Euler OR axis+angle
`rotate.angle`	`number`	radians about axis
`rotate.axis`	`number[]`	[x,y,z], any length exactly 3 items
`rotate.center`	`number[]`	fixed point, mm exactly 3 items
`rotate.rx`	`number`	rad about world +X
`rotate.ry`	`number`	rad about world +Y
`rotate.rz`	`number`	rad about world +Z
`rotateZ` optional	`object`	a rotation about the world +Z axis
`rotateZ.angle`	`number`	rotation angle about +Z, radians
`rotateZ.center`	`number[]`	rotation centre [x,y,z] in mm, default [0,0,0] exactly 3 items
`suppressed` optional	`boolean`	true = not built
`translate` optional	`number[]`	[x,y,z] mm exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mirror` write Mirror

Mirror a solid across a plane through the origin.

Full description

normal [nx,ny,nz] defines the mirror plane (through the world origin). Example: {"op":"mirror","id":"mirrored","of":"src","normal":[1,0,0]}

Argument	Type	Meaning & bounds
`normal` required	`number[]`	[x,y,z] mm exactly 3 items
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_copy` write Copy

Duplicate a solid unchanged.

Full description

A plain clone of of at the same location — the identity case of transform. Example: {"op":"copy","id":"dup","of":"src"}

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_pattern_copies` write Pattern copies

Linear, circular or direction-driven array of copies of a solid.

Full description

Call cad_help({tool:"cad_pattern_copies"}) for the rest.

Argument	Type	Meaning & bounds
`count` required	`integer`	an integer >= 2 ≥ 2
`of` required	`string`	body handle length ≥ 1
`type` required	`enum`	pattern kind — "linear" (needs "step"), "circ… one of "linear", "circular", "directions"
`center` optional	`number[]`	[x,y,z] mm exactly 3 items
`directions` optional	`number[][]`	one direction vector per pattern instance, inst… ≥ 2 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`step` optional	`number[]`	[x,y,z] mm exactly 3 items
`suppressed` optional	`boolean`	true = not built
`totalAngle` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_split_plane` destructive Split by plane

Cut a solid with a plane — or with a curved SURFACE — and keep one half, or both lumps.

Full description

Retires of and the discarded half. point (any point on the cut plane) + normal define the plane; keep ("above"|"below", default "above") selects which side of the normal survives. Call cad_help({tool:"cad_split_plane"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`cutter` optional	`object`	the SURFACE to cut with, extended infinitely: {…
`cutter.kind`	`enum`	— one of "cylinder", "face", "sheet", "plane"
`cutter.axis`	`number[]`	cylinder: the axis direction exactly 3 items
`cutter.faceId`	`string`	face: a raw STEP face id of ANY body in the doc… length ≥ 1
`cutter.normal`	`number[]`	plane: the plane normal exactly 3 items
`cutter.point`	`number[]`	cylinder: a point on the axis · plane: a point… exactly 3 items
`cutter.radius`	`number`	cylinder: the cutter radius in millimetres > 0
`cutter.sheetBodyId`	`string`	sheet: an OPEN sheet body id; every face of it… length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keep` optional	`enum`	which half-space to keep, relative to the cut p… one of "above", "below"
`keepFailed` optional	`boolean`	—
`normal` optional	`number[]`	[x,y,z] mm exactly 3 items
`point` optional	`number[]`	[x,y,z] mm exactly 3 items
`suppressed` optional	`boolean`	true = not built

Exactly one of these argument shapes: point + normal — or — cutter. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_split_face` destructive Split face

Split one face of a solid along a cutting plane into two (or more) pieces, without separating the solid.

Full description

Retires of, publishes ONE new solid — unlike split_plane, no material is removed and nothing is discarded. Call cad_help({tool:"cad_split_face"}) for the rest.

Argument	Type	Meaning & bounds
`faceId` required	`string`	— length ≥ 1
`normal` required	`number[]`	[x,y,z] mm exactly 3 items
`of` required	`string`	body handle length ≥ 1
`point` required	`number[]`	[x,y,z] mm exactly 3 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_split_edge` destructive Split edge

Subdivide one edge of a solid into two edges sharing a new vertex, without changing geometry.

Full description

Retires of, publishes ONE new solid. Call cad_help({tool:"cad_split_edge"}) for the rest.

Argument	Type	Meaning & bounds
`edgeId` required	`string`	— length ≥ 1
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`point` optional	`number[]`	[x,y,z] mm exactly 3 items
`suppressed` optional	`boolean`	true = not built
`t` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_split_periodic_face` destructive Split periodic face

Split a periodic (single-seam) face at its seam into two non-periodic faces.

Full description

Retires of, publishes ONE new solid. Call cad_help({tool:"cad_split_periodic_face"}) for the rest.

Argument	Type	Meaning & bounds
`faceId` required	`string`	— length ≥ 1
`of` required	`string`	body handle length ≥ 1
`angle` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_stitch` write Stitch

Sew coincident-edge sheet bodies into ONE manifold solid.

Full description

bodies is a list of earlier op ids (NOT of/tool — there is no base/tool asymmetry among several sheets). tol has no default: resolved from the model's STEP tolerance, refusing to run if the resolved tolerance would bridge distinct corners. Call cad_help({tool:"cad_stitch"}) for the rest.

Argument	Type	Meaning & bounds
`bodies` required	`string[]`	non-empty strings ≥ 1 items
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`tol` optional	`number`	— > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_segment_components` read Segment a body into connected components

Group a body's own faces into CONNECTED COMPONENTS over shell adjacency (shared edges) — answers "is this one connected piece, or several disjoint ones sharing a single solid id" for a body a checked op never refused (every manifold/watertight check passes N disjoint watertight pieces just as cleanly as one).

Full description

Call cad_help({tool:"cad_segment_components"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	id or "<id>#<n>"
`summary` optional	`boolean`	CADSF-2183: counts + bounding boxes only -- omi…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Shaft features & turned parts · 6

Turned-part vocabulary as first-class operations, so a shaft — or a chair leg — is described the way it is manufactured rather than reconstructed from booleans.

`cad_shaft_shoulder` destructive Shaft shoulder / step

Turn a shaft down to a smaller diameter beyond a shoulder face, with an optional relief undercut.

Full description

Retires of. z is the shoulder face, diameter the turned-down diameter beyond it, side ("above" default, or "below") which end is reduced. Call cad_help({tool:"cad_shaft_shoulder"}) for the rest.

Argument	Type	Meaning & bounds
`diameter` required	`number`	— > 0
`of` required	`string`	body handle length ≥ 1
`z` required	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`relief` optional	`object`	relief undercut at the inside corner of the sho…
`relief.depth`	`number`	undercut depth below the turned diameter, mm > 0
`relief.form`	`enum`	default "square" (a rectangular plunge recess)… one of "square", "round"
`relief.width`	`number`	undercut length along the axis, mm — omit for… > 0
`side` optional	`enum`	default "above" — which end of the shaft is t… one of "above", "below"
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_shaft_groove` destructive Shaft groove

Cut a circumferential groove in a turned shaft — square-shouldered (retaining-ring) or full-radius (seal).

Full description

Retires of. of must be a solid of revolution about +Z (a cylinder, a revolve, or the result of another shaft_* op). Call cad_help({tool:"cad_shaft_groove"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`width` required	`number`	— > 0
`z` required	`number`	—
`depth` optional	`number`	— > 0
`diameter` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`form` optional	`enum`	default "rectangular" — the square-shouldered… one of "rectangular", "round"
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`surface` optional	`enum`	outer (default)\|bore one of "outer", "bore"
`toolMatch` optional	`boolean \| object \| string`	match stocked tools

Exactly one of these argument shapes: depth — or — diameter. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_shaft_keyway` destructive Shaft keyway

Mill an axial parallel keyway (square-ended, BS 4235-1 / DIN 6885-1 form B) into a cylindrical section of a shaft.

Full description

Retires of. Call cad_help({tool:"cad_shaft_keyway"}) for the rest.

Argument	Type	Meaning & bounds
`length` required	`number`	— > 0
`of` required	`string`	body handle length ≥ 1
`z` required	`number`	—
`azimuth` optional	`number`	—
`depth` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`standard` optional	`enum`	look the key width b and the slot depth up from… one of "BS4235", "DIN6885"
`suppressed` optional	`boolean`	true = not built
`surface` optional	`enum`	outer (default)\|bore one of "outer", "bore"
`width` optional	`number`	— > 0

Exactly one of these argument shapes: width + depth — or — standard. No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_shaft_center_drill` destructive Shaft centre drill

Drill a centre hole (pilot bore + 60 degree protecting countersink) in a shaft end face.

Full description

Retires of. Call cad_help({tool:"cad_shaft_center_drill"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`pilotDepth` required	`number`	— > 0
`pilotDiameter` required	`number`	— > 0
`angle` optional	`number`	included angle in DEGREES… > 0 · < 180
`countersinkDiameter` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`end` optional	`enum`	default "top" — which end face is centre-dril… one of "top", "bottom"
`keepFailed` optional	`boolean`	—
`pointAngle` optional	`number \| null`	drill-point included angle in DEGREES at the pi… > 0 · < 180
`suppressed` optional	`boolean`	true = not built
`toolMatch` optional	`boolean \| object \| string`	match stocked tools

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_revolve_feature` destructive Revolve grooves / steps / lands

Cut grooves, machined steps and seal lands into an existing solid of revolution — outer walls, bores, CONES and flange faces — many features in one rebuild.

Full description

Retires of. of must be a solid of revolution about +Z (a revolve, a cylinder, or another revolve_feature/shaft_* result). Call cad_help({tool:"cad_revolve_feature"}) for the rest.

Argument	Type	Meaning & bounds
`features` required	`object[]`	the features to cut/raise in ONE profile rebuil… ≥ 1 items
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_turned_leg` write Turned leg

Turn a chair leg or spindle: a taper with beads, coves and an integral tenon or dowel end, stood on the floor at a splay with its top cut to mate the seat underside.

Full description

Call cad_help({tool:"cad_turned_leg"}) for the rest.

Argument	Type	Meaning & bounds
`bottomDiameter` optional	`number`	— > 0
`collar` optional	`number`	— > 0
`document` optional	`string`	handle or "new" length ≥ 1
`end` optional	`object \| string`	the integral end at the TOP of the leg, on the…
`features` optional	`object[]`	lathe details on the taper, in any order; each…
`foot` optional	`object`	a straight FOOT band under the taper…
`foot.height`	`number`	height of the straight foot band from the floor… > 0
`foot.diameter`	`number`	foot band diameter, mm… > 0
`keepFailed` optional	`boolean`	—
`length` optional	`number`	— > 0
`margin` optional	`number`	— > 0
`placement` optional	`object`	where the leg stands and how it leans.
`placement.anchor`	`enum`	default "foot". one of "foot", "top"
`placement.floorZ`	`number`	the floor plane the foot's lowest point rests o…
`placement.point`	`number[]`	anchor "foot": the foot centre's plan position… ≥ 2 items · ≤ 3 items
`placement.splayX`	`number`	degrees the leg's TOP leans toward +X (default 0).
`placement.splayY`	`number`	degrees the leg's TOP leans toward +Y (default 0)
`suppressed` optional	`boolean`	true = not built
`topDiameter` optional	`number`	— > 0
`trimTopTo` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Joinery · 2

Real joints between two parts that stay two parts, and real standard fasteners through a stack of parts: the mortise is cut in one member and the tenon formed on the other, or a catalogue screw is placed on an axis and each part it passes gets the pilot, clearance, counterbore or countersink hole its material asks for.

`cad_joint` write Joint

Form a REAL joint between two named parts and keep them two parts: mortise-and-tenon, wedged through-tenon, dowel, half-lap, bridle or a revolute "pin" stack; CLEARANCE goes on the mortise, and "finger"/"dovetail" are refused by name.

Full description

The only verb that takes TWO bodies and leaves TWO. Call cad_help({tool:"cad_joint"}) for the rest.

Argument	Type	Meaning & bounds
`partA` required	`string`	body handle length ≥ 1
`partB` required	`string`	body handle length ≥ 1
`angle` optional	`number`	—
`axis` optional	`enum`	the WORLD axis the entering member (`partA`) tr… one of "x", "y", "z"
`bush` optional	`enum`	pin: bush in partA one of "iso3547", "none"
`clearance` optional	`number`	—
`count` optional	`integer`	— ≥ 1
`depth` optional	`number`	— > 0
`diameter` optional	`number`	— > 0
`direction` optional	`enum`	which way along `axis` the entering member trav… one of 1, -1
`document` optional	`string`	handle or "new" length ≥ 1
`fit` optional	`string`	pin: ISO 286 fit, default "H8/f7" pattern `^[A-Z]\d{1,2}/[a-z]\d{1,2}$`
`float` optional	`number`	— > 0
`haunch` optional	`boolean \| number`	mortise_tenon only: keep a short strip of the e…
`haunchLength` optional	`number`	— > 0
`journal` optional	`enum`	pin: default "bolt" under Ø8 one of "bolt", "sleeve"
`keepFailed` optional	`boolean`	—
`kerfDepth` optional	`number`	— > 0
`kerfWidth` optional	`number`	— > 0
`kind` optional	`enum`	default "mortise_tenon". one of "mortise_tenon", "through_tenon_wedged", "dowel", "half_lap", "bridle", "pin", "finger", "dovetail"
`offset` optional	`object`	shift the tenon off the entering member's secti…
`offset.x`	`number`	mm off the entering member's own section centre…
`offset.y`	`number`	mm off the entering member's own section centre…
`offset.z`	`number`	mm off the entering member's own section centre…
`pinAxis` optional	`number[]`	[x,y,z] mm exactly 3 items
`pinPoint` optional	`number[]`	[x,y,z] mm exactly 3 items
`position` optional	`number`	—
`protrusion` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built
`tenonLength` optional	`number`	— > 0
`tenonThickness` optional	`number`	— > 0
`tenonWidth` optional	`number`	— > 0
`tol` optional	`number`	— > 0
`wedges` optional	`integer`	— ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fastener` write Fastener

Place a STANDARD fastener; the part's MATERIAL decides the hole: PILOT, clearance or TAP DRILL, thread a SIMPLIFIED annotation.

Full description

Call cad_help({tool:"cad_fastener"}) for the rest.

Argument	Type	Meaning & bounds
`axis` required	`enum`	the direction the fastener… one of "x", "-x", "y", "-y", "z", "-z"
`kind` required	`enum`	which STANDARD fastener to… one of "socket_cap", "button", "hex_bolt", "wood_screw", "csk_100", "csk_iso7046", "csk_iso10642", "csk_raised_iso7047", "pan_iso7045", "connector_bolt", "dowel_pin", "insert", "stud"
`point` required	`number[]`	[x,y,z] mm exactly 3 items
`size` required	`number \| string`	the nominal size.
`allowGaps` optional	`boolean`	—
`boltClearance` optional	`number`	mm, >= 0 ≥ 0
`clearanceGrade` optional	`enum`	default "medium" — which… one of "fine", "medium", "coarse"
`counterbore` optional	`boolean`	—
`countersink` optional	`boolean`	—
`document` optional	`string`	handle or "new" length ≥ 1
`drive` optional	`enum`	the drive recess cut into t… one of "pozidriv", "phillips", "hex", "torx", "none"
`flangeMinWall` optional	`number`	—
`host` optional	`string[]`	non-empty strings ≥ 1 items
`insert` optional	`object`	CADSF-102136: a POTTED INSE…
`insert.length`	`number`	overall insert length along… > 0
`insert.od`	`number`	barrel outside Ø, mm > 0
`insert.boreDia`	`number`	insert bore Ø, mm… > 0
`insert.flangeOd`	`number`	flange Ø at the insert top… > 0
`insert.flangeThk`	`number`	flange thickness, mm > 0
`insert.top`	`number`	local z of the insert top o…
`keepFailed` optional	`boolean`	—
`length` optional	`number \| string`	—
`materials` optional	`object`	REQUIRED with `parts`… ≥ 1 keys
`name` optional	`string`	a string — for blend's `a…
`nut` optional	`boolean`	—
`parts` optional	`string[]`	non-empty strings ≥ 1 items
`pottingGap` optional	`number`	mm, >= 0 ≥ 0
`suppressed` optional	`boolean`	true = not built
`tapped` optional	`boolean`	—
`thread` optional	`enum`	"modelled" = the real ISO 6… one of "cosmetic", "modelled"
`threadLength` optional	`number`	— > 0
`through` optional	`boolean`	—
`tol` optional	`number`	— > 0
`washer` optional	`boolean \| string`	fit DIN 125-A plain washer(s).
`wetted` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Datums, parameters & model state · 24

The parametric layer: datum geometry to build against, named parameters you can read and set, the plan normaliser that turns a spec into ops, and the document state itself.

`cad_datum_plane` write Datum plane

Construction reference PLANE (no B-rep, never written to STEP).

Full description

method: "offset" (of+face, or origin+normal, plus distance), "midplane" (of+faceA+faceB, must be parallel), "three_point" (points, 3x [x,y,z] — winding sets the normal by the right-hand rule). Its frame {origin,xAxis,yAxis,normal} can be used as a sketch's plane. Call cad_help({tool:"cad_datum_plane"}) for the rest.

Argument	Type	Meaning & bounds
`method` required	`string`	— length ≥ 1
`distance` optional	`number`	—
`document` optional	`string`	handle or "new" length ≥ 1
`face` optional	`object \| string`	a face selector
`faceA` optional	`object \| string`	a face selector
`faceB` optional	`object \| string`	a face selector
`keepFailed` optional	`boolean`	—
`normal` optional	`number[]`	[x,y,z] mm exactly 3 items
`of` optional	`string`	body handle length ≥ 1
`origin` optional	`number[]`	[x,y,z] mm exactly 3 items
`points` optional	`number[][]`	exactly 3 [x,y,z] points (mm) exactly 3 items
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_datum_axis` write Datum axis

Construction reference AXIS.

Full description

method: "two_point" (points, 2x [x,y,z]), "face_normal" (of+face+point), "cylinder" (of+face, the axis of a cylindrical/conical face). Example: {"op":"datum_axis","id":"ax1","method":"two_point","points":[[0,0,0],[0,0,100]]}

Argument	Type	Meaning & bounds
`method` required	`string`	— length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`face` optional	`object \| string`	a face selector
`keepFailed` optional	`boolean`	—
`of` optional	`string`	body handle length ≥ 1
`point` optional	`number[]`	[x,y,z] mm exactly 3 items
`points` optional	`number[][]`	exactly 2 [x,y,z] points (mm) exactly 2 items
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_datum_point` write Datum point

Construction reference POINT.

Full description

method: "vertex" (explicit point), "edge_midpoint" (of+edge, or explicit points 2x [x,y,z] endpoints). Example: {"op":"datum_point","id":"p1","method":"vertex","point":[10,10,0]}

Argument	Type	Meaning & bounds
`method` required	`string`	— length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`edge` optional	`string`	— length ≥ 1
`keepFailed` optional	`boolean`	—
`of` optional	`string`	body handle length ≥ 1
`point` optional	`number[]`	[x,y,z] mm exactly 3 items
`points` optional	`number[][]`	exactly 2 [x,y,z] points (mm) exactly 2 items
`suppressed` optional	`boolean`	true = not built

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_param_get` read Read a named parameter

Named parameters live OUTSIDE a command document's ops[] array (passed as run()'s opts.params, or a project file's reserved params key — see cli.js's runProjectFile) and are referenced from op fields as "param:name" or an inline expression string (commands/param-resolve.js).

Full description

This op reads back createParamTable().getParam(name). Call cad_help({tool:"cad_param_get"}) for the rest.

Argument	Type	Meaning & bounds
`name` required	`string`	parameter name pattern `^[A-Za-z_][A-Za-z0-9_]*$`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_param_set` write Create or update a named parameter

Expressions are evaluated by commands/expr.js's safe recursive-descent parser (no eval()/Function()); may reference any other parameter by name.

Full description

A cyclic reference, unknown name, or division-by-zero becomes a per-parameter .error string, never a throw. Wraps createParamTable().setParam(name, expr). Call cad_help({tool:"cad_param_set"}) for the rest.

Argument	Type	Meaning & bounds
`expr` required	`string`	e.g. "40", "width/2 + 5" — may reference othe… length ≥ 1
`name` required	`string`	must start with a letter/underscore; letters, d… pattern `^[A-Za-z_][A-Za-z0-9_]*$`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_param_list` read List every named parameter

List every named parameter in the active document's parameter table: name, expression, current value, and any evaluation error (unknown reference, cyclic reference, division by zero).

Full description

Call this before cad_param_set on an unfamiliar model to see what already exists and what depends on what.

Takes no arguments.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_build_plan` write Build plan

Run a whole BUILD PLAN — an ordered list of kernel operations — in ONE call, instead of one tool call per operation.

Full description

Pass cad_spec_configure's result (or just its "plan") straight through, unedited; a bare list of ops works too. A step "id" is not a body handle. Call cad_help({tool:"cad_build_plan"}) for the rest.

Argument	Type	Meaning & bounds
`plan` required	`array \| object`	the operations to run, in order.
`document` optional	`string`	handle or "new" length ≥ 1
`fill` optional	`object`	fields to merge into individual steps before ru…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_batch` write Run several tool calls in one call

Run an ordered list of THIS SERVER'S OWN tool calls in one request, passing each result to the next.

Full description

Use it whenever you already know the next two or more calls: a nine-feature part is nine round trips otherwise, each paid for as a full result frame. Ops run serially in the same session, exactly as if you had called them one at a time. Call cad_help({tool:"cad_batch"}) for the rest.

Argument	Type	Meaning & bounds
`ops` required	`object[]`	The calls to run, in order. ≥ 1 items · ≤ 64 items
`atomic` optional	`boolean`	All or nothing (default false): if any op fails…
`result` optional	`enum`	"compact" (default): per-op {index, tool, ok, h… one of "compact", "full"
`stopOnError` optional	`boolean`	Stop at the first failing op and report it as t…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bytes` optional	`object`	ops = summed size of the individual frames this…
`completedOps` optional	`any[]`	Promoted batch: ops that finished before the so…
`count` optional	`number`	Ops actually run…
`failedCount` optional	`number`	Present when ok is false (stopOnError:false): h…
`handles` optional	`object`	Present when ok is false (stopOnError:false): l…
`jobId` optional	`string`	Promoted batch: the job running pendingOp.
`mode` optional	`string`	—
`ok` optional	`boolean`	True when every op succeeded…
`ops` optional	`object[]`	—
`pendingOp` optional	`object`	Promoted batch: {index, tool} of the op now run…
`pollAfterMs` optional	`number`	—
`promoted` optional	`boolean`	True when a long op was promoted to an async jo…
`remainingOps` optional	`any[]`	Promoted batch: ops after pendingOp that were N…
`result` optional	`object`	The final op's full result ("compact" mode).

`cad_list_model_state` read List live documents and body handles

List every document and handle (solid/face/edge/sketch/sheet/group) currently live in this server's session: what a restart or a lost context cannot recover any other way.

Full description

Call this after an E_NOT_FOUND on a handle you expected to still exist, or at the start of a session to see what (if anything) is already there. Call cad_help({tool:"cad_list_model_state"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	Limit the listing to one document handle…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`client` optional	`string \| null`	The client scope listed…
`documents` optional	`object[]`	—
`humanEditsSinceLastCall` optional	`object[]`	Live edit: what a person changed since your las…
`journal` optional	`string \| null`	Path to this session's op journal, or null when…
`liveEdit` optional	`object \| null`	Live-edit status; null when off.
`restored` optional	`object \| null`	Non-null when the documents below were rebuilt…
`sessionEpoch` optional	`string \| null`	—
`sessionReset` optional	`object \| null`	Non-null when the PREVIOUS boot had live geomet…
`usage` optional	`object`	session.getUsage() for the active session — b…

`cad_set_part` write Name a body as a part (name, material, quantity, colour)

SAY WHAT A BODY IS.

Full description

Stamps a part name (and optionally a material and a quantity) onto one or more bodies, so a document of loose solids becomes an assembly of named parts. Call cad_help({tool:"cad_set_part"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string \| array`	The body (or bodies) to stamp: a handle an earl…
`part` required	`string`	The part name or part number. length 1–255
`color` optional	`string \| array`	US spelling of "colour" (same value)
`colour` optional	`string \| array`	CADSF-2886: the part's colour, "#RRGGBB" / "#RG…
`document` optional	`string`	Which session document the bodies are in.
`flow` optional	`object`	—
`material` optional	`string`	Free-text material label… length ≤ 255
`qty` optional	`integer`	How many of this part THIS BODY stands for… ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`document` optional	`string \| null`	—
`parts` optional	`object[]`	One row per stamped body: {ref, solid, part, ma…
`stamped` optional	`integer`	—

`cad_delete_body` destructive Delete a body from its document

Remove ONE body (or sheet, mesh, group, sketch) from its document: the op that produced it is taken out of the document's op list, the rest is rebuilt, and its handles are released — so it stays gone across every later call, and cad_list_model_state no longer lists it.

Full description

Call cad_help({tool:"cad_delete_body"}) for the rest.

Argument	Type	Meaning & bounds
`body` required	`string`	The handle a modelling call returned… length ≥ 1
`document` optional	`string`	The document the body is in.
`force` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bodies` optional	`integer`	Live bodies left in the document.
`deleted` optional	`string`	The reference as given.
`document` optional	`string`	—
`ops` optional	`object[]`	Document ops removed: [{index, id, op}].
`released` optional	`string[]`	Session handles released.
`remainingOps` optional	`integer`	—

`cad_snapshot` write Freeze the document as a named version

Freeze a document's current state (its op list and handles) as a named version, cheaply — the op list is the model.

Full description

Keep modelling afterwards; cad_versions lists the versions, cad_restore rewinds to one, cad_branch forks a new document from one. Take one before a simulation or a risky edit so the result stays comparable. Names are unique per document (E_VERSION_EXISTS).

Argument	Type	Meaning & bounds
`name` required	`string`	The version name, unique within the document… length 1–64 · pattern `^[A-Za-z0-9][A-Za-z0-9 _.-]*$`
`document` optional	`string`	The document to snapshot.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`document` optional	`string`	—
`version` optional	`object`	—
`version.createdAt`	`string`	—
`version.document`	`string`	—
`version.handles`	`integer`	—
`version.id`	`string`	—
`version.name`	`string`	—
`version.opCount`	`integer`	—
`version.parent`	`string \| null`	parent version
`version.results`	`object[]`	[{tool,at,summary}]
`version.summary`	`object \| null`	{bbox,volume,bodies}

`cad_branch` write Fork a new document from a version

Fork a NEW, independent document from a version: the version's ops are replayed into it and every body gets a fresh handle (handles maps the version's handles to the new ones).

Full description

The original document is untouched, so a variant can be modelled and simulated without contaminating the baseline. The new document starts with its own version named name (parent: from).

Argument	Type	Meaning & bounds
`from` required	`string`	The version to fork: its id ("v2") or its name. length ≥ 1
`name` required	`string`	Name of the new document's baseline version. length 1–64 · pattern `^[A-Za-z0-9][A-Za-z0-9 _.-]*$`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`document` optional	`string`	The new document handle — pass it as `documen…
`from` optional	`object`	—
`from.createdAt`	`string`	—
`from.document`	`string`	—
`from.handles`	`integer`	—
`from.id`	`string`	—
`from.name`	`string`	—
`from.opCount`	`integer`	—
`from.parent`	`string \| null`	parent version
`from.results`	`object[]`	[{tool,at,summary}]
`from.summary`	`object \| null`	{bbox,volume,bodies}
`handles` optional	`object`	Version handle -> the new document's handle for…
`replayed` optional	`integer`	—
`version` optional	`object`	—
`version.createdAt`	`string`	—
`version.document`	`string`	—
`version.handles`	`integer`	—
`version.id`	`string`	—
`version.name`	`string`	—
`version.opCount`	`integer`	—
`version.parent`	`string \| null`	parent version
`version.results`	`object[]`	[{tool,at,summary}]
`version.summary`	`object \| null`	{bbox,volume,bodies}

`cad_restore` destructive Rewind a document to a version

Rewind a document to one of its versions: the op list becomes the version's and is rebuilt.

Full description

Handles minted after the version stop resolving (released); handles the version had come back under their original names. The current state is NOT saved first — cad_snapshot it if you may want it back. A version of another document is refused (E_CONFLICT): cad_branch it instead.

Argument	Type	Meaning & bounds
`version` required	`string`	The version to rewind to: its id or its name in… length ≥ 1
`document` optional	`string`	The document to rewind.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bodies` optional	`integer`	—
`document` optional	`string`	—
`rebound` optional	`string[]`	Handles the version had that are live again.
`released` optional	`string[]`	Handles minted after the version, now gone.
`replayed` optional	`integer`	—
`version` optional	`object`	—
`version.createdAt`	`string`	—
`version.document`	`string`	—
`version.handles`	`integer`	—
`version.id`	`string`	—
`version.name`	`string`	—
`version.opCount`	`integer`	—
`version.parent`	`string \| null`	parent version
`version.results`	`object[]`	[{tool,at,summary}]
`version.summary`	`object \| null`	{bbox,volume,bodies}

`cad_versions` read List a document's versions

List the versions of a document (or of every document), newest first: id, name, op count, bbox/volume/body count when taken, parent, and the simulation results (cad_wind_tunnel, cad_fea_*) recorded while the document sat at that version.

Full description

Versions survive a restart.

Argument	Type	Meaning & bounds
`document` optional	`string`	The document whose versions to list.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`current` optional	`string \| null`	The version the document sits at exactly…
`document` optional	`string \| null`	—
`versions` optional	`object[]`	—

`cad_session_reset` destructive Close every document and start clean

Close EVERY document and handle in YOUR session on this server and forget the documents a previous boot's journal was holding, so the next modelling call starts in a fresh, empty document.

Full description

Call cad_help({tool:"cad_session_reset"}) for the rest.

Argument	Type	Meaning & bounds
`confirm` required	`boolean`	Must be exactly true.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`client` optional	`string \| null`	The client scope that was reset.
`closedDocuments` optional	`string[]`	Document handles that were live (or restorable)…
`journal` optional	`string \| null`	The fresh journal file this session now writes…
`sessionEpoch` optional	`string \| null`	—

`cad_save` destructive Save the document as STEP

Export every solid in the document to the STEP file path; schema picks AP203/AP214/AP242.

Full description

Call cad_help({tool:"cad_save"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`string`	— length ≥ 1
`colors` optional	`object`	— ≥ 1 keys
`colours` optional	`object`	Body colours in the STEP. ≥ 1 keys
`compress` optional	`boolean`	—
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`schema` optional	`enum`	— one of "ap203e1", "ap203e2", "ap214", "ap242e1", "ap242e2", "ap242e3", "ap203", "ap242", "source"
`strict` optional	`boolean`	—
`suppressed` optional	`boolean`	true = not built
`tessellated` optional	`enum`	AP242 mesh beside/instead of B-rep. one of "none", "add", "only"
`units` optional	`enum`	File length unit. one of "um", "mm", "cm", "m", "in", "ft"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_feature_diagnose` read What is wrong with a feature (and the whole tree's state)

WHAT IS WRONG with a feature: every feature's state (ok / warning / error / suppressed / suppressedByFailure / stale), whether the document is PARTIAL because something did not build, and, for one named feature, its refusal, the feature that actually broke, and the repair verbs to try.

Full description

Call cad_help({tool:"cad_feature_diagnose"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	Which document. Omit for the default/active one.
`featureId` optional	`string`	The feature to diagnose: the id a modelling cal… length ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`counts` optional	`object`	How many features are in each state.
`diagnosis` optional	`object \| null`	Present when "featureId" was given: {state, err…
`document` optional	`string \| null`	—
`featureRows` optional	`object`	Only past 64 features: {listed, of, omittedOk…
`features` optional	`object[]`	One row per feature in program order: {index, f…
`lastGood` optional	`object`	The last feature up to which EVERY feature buil…
`partial` optional	`boolean`	true when at least one feature contributed no g…
`warning` optional	`string \| null`	The one-line "this is not the whole program" wa…

`cad_feature_suppress` write Suppress (or un-suppress) one feature

TURN ONE FEATURE OFF WITHOUT DELETING IT -- the feature tree's eye toggle: a suppressed feature is not built, features that reference it are skipped too, and everything independent of it still builds, so a document whose feature 7 of 20 cannot build becomes usable again while you work out the real fix.

Full description

Call cad_help({tool:"cad_feature_suppress"}) for the rest.

Argument	Type	Meaning & bounds
`featureId` required	`string`	The feature: the id a modelling call returned… length ≥ 1
`document` optional	`string`	Which document. Omit for the default/active one.
`force` optional	`boolean`	—
`suppressed` optional	`boolean`	true (the default) suppresses the feature; fals…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`changed` optional	`boolean`	false when the feature was already in that stat…
`document` optional	`string \| null`	—
`feature` optional	`string \| null`	—
`featureRows` optional	`object`	Only past 64 features, as cad_feature_diagnose.
`features` optional	`object[]`	—
`index` optional	`integer`	—
`lastGood` optional	`object`	—
`op` optional	`string \| null`	—
`partial` optional	`boolean`	—
`replayed` optional	`integer`	Features replayed.
`suppressed` optional	`boolean`	—
`warning` optional	`string \| null`	—

`cad_feature_edit` write Edit a feature

Change an existing feature's parameters in place ({"diameter": 6.6}) and rebuild what follows, instead of re-creating it.

Full description

Returns the before/after diff.

Argument	Type	Meaning & bounds
`featureId` required	`string`	Id, index or body handle. length ≥ 1
`set` required	`object`	{param: value}; null removes.
`document` optional	`string`	—
`force` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_edit_guarded` write Edit with a firewall

Edit an existing model as param/feature changes (or one appended feature), recompute, and prove nothing outside the edit changed; on fail roll back (an .FCStd byte-identical).

Full description

FreeCAD .FCStd: call inspect:true first to list sketch constraints, geometry and patterns. Call cad_help({tool:"cad_edit_guarded"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	—
`dryRun` optional	`boolean`	—
`edits` optional	`object[]`	— ≥ 1 items
`expect` optional	`object`	Declared affected region {features:[names], bbo…
`fcstd` optional	`string`	.FCStd path; omit for the session document.
`force` optional	`boolean`	—
`inspect` optional	`boolean`	FCStd: list sketches + patterns; edits nothing.
`margin` optional	`number`	—
`out` optional	`string`	FCStd: write the result here instead of in place.
`targets` optional	`object[]`	[{volume}\|{bboxSize}\|{cylinderDiameter, near?}\|…
`tolerance` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_job_status` read Async job status

Status of an async job (a long op that returned a jobId, e.g.

Full description

cad_mesh_to_brep with jobMode:true): state queued/running/done/failed/cancelled/lost, stage, pct, progress.components {done,total} (component-route builds) with etaMs, elapsedMs, pollAfterMs, summary. Omit jobId to list this session's jobs. Call cad_help({tool:"cad_job_status"}) for the rest.

Argument	Type	Meaning & bounds
`jobId` optional	`string`	the jobId a long op returned pattern `^job_[a-z0-9]{6,40}$`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_job_result` read Async job result

The result of a finished async job: exactly the response the original tool would have returned inline (handle, document, report), plus _meta.job.

Full description

waitMs (<= 25000) waits for a running job first, so a short job needs one round trip. A job still running refuses E_PRECONDITION (poll cad_job_status); a failed job returns its own error.

Argument	Type	Meaning & bounds
`jobId` required	`string`	the jobId a long op returned pattern `^job_[a-z0-9]{6,40}$`
`waitMs` optional	`integer`	wait up to this long ≥ 0 · ≤ 25000

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_job_cancel` read Cancel async job

Cancel an async job: a queued job is dropped, a running one has its kernel-worker build terminated and its op rolled back (state becomes "cancelled"; cad_job_result then answers E_CANCELLED).

Full description

A finished job is left as it is.

Argument	Type	Meaning & bounds
`jobId` required	`string`	the jobId a long op returned pattern `^job_[a-z0-9]{6,40}$`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Query, measurement & preview · 12

Reading rather than changing: addressable topology, distances and angles, mass properties, tolerance stacks, the tessellation and image previews that let an agent SEE what it built, and the design-knowledge packs that supply a product type's real numbers before any of it is modelled.

`cad_body_topology` read List a body's faces and edges

Enumerate every face and edge of a body already built in the active session, by the exact DOCUMENT id cad_fillet_edges/cad_chamfer_edges' "edges" field accepts — the query a blend/chamfer refusal's "fillet the edges you want instead: edges:[...]" advice has always assumed exists.

Full description

Call cad_help({tool:"cad_body_topology"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	id or "<id>#<n>"
`compact` optional	`boolean`	Return each edge as {edgeId, curveType, vertice…
`include` optional	`enum[]`	Which topology to return; omit (or leave empty)…
`limit` optional	`integer`	Page the "edges" array to at most this many ent… ≥ 1
`offset` optional	`integer`	With "limit": skip this many edges first — pa… ≥ 0 · default `0`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_face_edges` read List one face's boundary edges, grouped into tangent chains

Given ONE face of a body already built in the active session, return its boundary as the structure the geometry has: face -> LOOPS (one outer bound plus one per hole/pocket) -> CHAINS (each loop split at its non-tangent corners) -> edge ids.

Full description

Call cad_help({tool:"cad_face_edges"}) for the rest.

Argument	Type	Meaning & bounds
`face` required	`string`	Face id to enumerate — a "faceId" from cad_bo…
`solid` required	`string`	id or "<id>#<n>"
`compact` optional	`boolean`	Return each "edges" entry as {edgeId, curveType…
`include` optional	`enum[]`	Which sections to return; omit (or leave empty)…
`kernelChains` optional	`boolean`	Cross-check each chain against the kernel's she…
`limit` optional	`integer`	Page the "edges" section (include:["edges"]) to… ≥ 1
`mixedFamilies` optional	`boolean`	Treat a tangent LINE->CIRCLE join as continuing…
`offset` optional	`integer`	With "limit": skip this many edges first — pa… ≥ 0 · default `0`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_measure` read Measure (point / ray / distance queries)

One schema, five query kinds selected by kind: "point_in_body" (classify a point in/out/on one solid), "closest_point" (nearest point on one solid's boundary to a query point), "ray_fire" (every forward hit of a ray against 1+ solids), "distance" (closest approach between two solids; 0 if touching or interpenetrat…

Full description

ing within tolerance). Call cad_help({tool:"cad_measure"}) for the rest.

Argument	Type	Meaning & bounds
`kind` required	`enum`	Which measurement to take — decides which oth… one of "point_in_body", "closest_point", "ray_fire", "distance", "section"
`direction` optional	`number[]`	ray direction (need not be unit length) exactly 3 items
`firstOnly` optional	`boolean`	return only the single globally-nearest hit acr…
`normal` optional	`number[]`	the cut plane's normal (need not be unit length) exactly 3 items
`origin` optional	`number[]`	ray origin, mm exactly 3 items
`point` optional	`number[]`	query point, mm exactly 3 items
`solid` optional	`string`	body handle length ≥ 1
`solidA` optional	`string`	body handle length ≥ 1
`solidB` optional	`string`	body handle length ≥ 1
`solids` optional	`array \| string`	—
`tol` optional	`number`	override the default distance-to-boundary "on"… > 0

Exactly one of these argument shapes: kind + solid + point — or — kind + solid + point — or — kind + solids + origin + direction — or — kind + solidA + solidB — or — kind + solid + point + normal.

`cad_mass_properties` read Mass properties (volume, area, centroid, inertia)

The exact feature vector an instant-quote / DFM front-end reads off an uploaded part (see GeometryStats.js's header — competitor-aware research citation: Paperless Parts / Xometry / Protolabs-style analysers).

Full description

Every number is derived from the watertight tessellation + B-rep topology, never hand-entered. Call cad_help({tool:"cad_mass_properties"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	body handle length ≥ 1
`csys` optional	`object`	optional: report centroid and inertia AGAIN, ex…
`csys.origin`	`number[]`	the user CSYS origin, in world mm exactly 3 items
`csys.xAxis`	`number[]`	the user CSYS +X direction, in world coordinate… exactly 3 items
`csys.yAxis`	`number[]`	the user CSYS +Y direction, in world coordinate… exactly 3 items
`thinWallThreshold` optional	`number`	mm — when given, thinWallCount reports how ma… > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_tolerance_stack` write Tolerance stack-up (worst case / RSS / Monte Carlo)

Add up a 1D chain of toleranced dimensions and report the resultant three ways: worst case, RSS, and, with "monteCarlo", a sampled distribution.

Full description

Call cad_help({tool:"cad_tolerance_stack"}) for the rest.

Argument	Type	Meaning & bounds
`members` required	`object[]`	The dimensions of the chain, IN CHAIN ORDER (face A to face B). Sources: cad_measure results, PMI read from an imported STEP file (cite it with "pmiId"), or a value the design assumes (supply "nominal"/"tolerance" and, to author it, "targets"). ≥ 1 items
`apply` optional	`boolean`	Author the datum scheme ("datums") and every supplied member's dimensional tolerance onto "solid" (CADSF-961) — see the tool description. Default false: a stack is a report until you say otherwise. Requires "solid".
`axis` optional	`number[]`	The stack's own traversal axis (unit vector, mm-space). Optional — when omitted, the axis is seeded from the first member that carries its own "axis". Only meaningful together with member "points" (see MEMBER_SCHEMA): without points on every member there is no geometry to check the axis against, and the chain is declared rather than verified either way. exactly 3 items
`datums` optional	`object[]`	The datum scheme this stack assumes. Authored via cad_pmi_author (kind:"datum") when apply/dryRun is set; ignored otherwise. Optional — a stack runs without it, but then the toleranced dimensions apply/dryRun authors have no datum scheme behind them in the exported STEP.
`dryRun` optional	`boolean`	With "apply" semantics active, report what WOULD be authored/updated (same "authoring" shape) without writing anything. Requires "solid".
`limits` optional	`object`	Requirement on the resultant (e.g. a gap that must stay between 0.05 and 0.60 mm). Adds a pass/fail verdict per analysis, and a sampled yield to the Monte Carlo run.
`limits.lower`	`number`	Lowest acceptable value of the RESULTANT, mm.
`limits.upper`	`number`	Highest acceptable value of the RESULTANT, mm.
`monteCarlo` optional	`object`	Run a Monte Carlo simulation as well as the closed forms. Omit to skip it.
`monteCarlo.distribution`	`enum`	Default distribution for members that do not name their own. Default "normal". one of "normal", "uniform", "triangular"
`monteCarlo.samples`	`integer`	Number of assemblies to sample. 10000 puts a 0.71% standard error on the spread (1/sqrt(2N)). ≥ 1 · ≤ 1000000
`monteCarlo.seed`	`integer`	PRNG seed; the same seed returns the same numbers. Default 1392 (0x570).
`name` optional	`string`	Optional name for the stack, echoed in the report.
`sigmaCap` optional	`number`	How many standard deviations the ± band of a member spans. Default 3 (the ±3σ convention); 6 for a six-sigma process capability. > 0
`solid` optional	`string`	Body handle already built in the active session (an earlier op's id, or "<id>#<n>"). Required by "apply"/"dryRun"; also used, when given, to resolve any member's "pmiId" against the model's live PMI even without applying.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_preview_body` read Render a preview image

Render a headless PNG of a body (or the whole active document) and return it as an image so you can visually verify the part you just built — no browser or GPU is used, this is a pure-software rasterizer.

Full description

The image is capped at 512x512 pixels to keep the response small; ask for a smaller "width" if you only need a quick check. Call cad_help({tool:"cad_preview_body"}) for the rest.

Argument	Type	Meaning & bounds
`azimuth` optional	`number`	Camera azimuth in degrees around the model…
`document` optional	`string`	a document handle length ≥ 1
`elevation` optional	`number`	Camera elevation in degrees above the horizon…
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate…
`healGeometry` optional	`boolean`	Attempt to heal small topology defects… default `false`
`height` optional	`integer`	Image height in pixels, capped; defaults to "wi… > 0 · ≤ 512
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its res… > 0
`of` optional	`string`	"all" (every live body in the active document,… default `"all"`
`tile` optional	`integer`	With "views": pixels per square tile… > 0 · ≤ 512
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviatio… > 0
`views` optional	`enum[]`	Render several ORTHOGRAPHIC views as one contac… ≥ 1 items · ≤ 8 items
`width` optional	`integer`	Image width in pixels, capped at 512. > 0 · ≤ 512 · default `512`
`wireframe` optional	`boolean`	With "views": add a hidden-line (HLR) wireframe…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_compare_silhouette` read Compare a body's silhouette to a reference drawing

Score a body against a rights-cleared reference silhouette per view (front/side/top/iso...), returning per-view IoU and the largest mismatch region.

Full description

Call cad_help({tool:"cad_compare_silhouette"}) for the rest.

Argument	Type	Meaning & bounds
`references` required	`object`	One entry per view, keyed by view name… ≥ 1 keys
`references.back`	`object`	—
`references.bottom`	`object`	—
`references.front`	`object`	—
`references.iso`	`object`	—
`references.left`	`object`	—
`references.right`	`object`	—
`references.side`	`object`	—
`references.top`	`object`	—
`align` optional	`enum`	fit (default): body bbox scaled/centred onto th… one of "fit", "none"
`document` optional	`string`	a document handle length ≥ 1
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate…
`image` optional	`boolean`	Also return a diff PNG per view…
`maxRegions` optional	`integer`	How many mismatch regions to list per view… ≥ 1 · ≤ 32
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its res… > 0
`of` optional	`string`	"all" (every live body in the active document,… default `"all"`
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviatio… > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_view_body` write Write an interactive 3D view

Write a fully self-contained interactive 3D viewer (.html) of a body or the whole active document and return {path, bytes, triangles, renderer} — never the file contents.

Full description

A HUMAN opens it in a browser to orbit/zoom the part. Call cad_help({tool:"cad_view_body"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`string`	Output .html path. Absolute paths are used as-is; relative paths resolve against the configured output directory (CADSOLVER_MCP_OUTPUT_DIR) when set, else the server process's cwd. Parent directories are created as needed.
`display` optional	`enum`	CADSF-610, "compact" renderer only (default "shaded+edges"): which display mode the page OPENS in — "shaded" (solid), "shaded+edges" (default: solid + B-rep edges), "hlr" (hidden-line removed, dark edges on a light ground, the solid drawn depth-only so it occludes but never paints), "wireframe" (every edge, hidden ones included). All four are switchable in the page itself (segmented control, or keys 1-4) whatever this is set to; it exists so an embedded/screenshotted view starts in the right one. Rejected with the "three" renderer, which has its own controls. one of "shaded", "shaded+edges", "hlr", "wireframe"
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field — use this to target a document OTHER than the session's default (e.g. a second part built with a modeling call's {"document":"new"}). Omit to use the session's default/active document. length ≥ 1
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating.
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`of` optional	`string`	"all" (every live body in the active document, merged) — the default — "<opId>" (body 0 of that op), or "<opId>#<bodyIndex>" (one body of a multi-body op). For format:"step", "all"/omitted still serializes the whole assembled document, but naming ONE body writes a STEP file containing ONLY that body (CADSB-144) — this is what lets two parts in the same document export as two separate STEP files without needing two documents; a "document":"new" modeling-tool call plus this tool's own "document" field is the OTHER way, for two parts you want to keep fully independent. default `"all"`
`overlay` optional	`string`	CADSF-1435: a second body/mesh ref drawn in the SAME scene as "of" — usually a mesh handle (the input STL) ghosted over "of" (the reconstructed solid); when "of" is itself a mesh, "overlay" may instead be a solid ref. Rejected together with "handle" or {"renderer":"compact"}.
`overlayMaxTriangles` optional	`integer`	CADSF-1435: triangle cap for the overlay layer (default 50000). An overlay mesh handle has no analytic surface to re-tessellate at a coarser tolerance (unlike "of"'s own LOD path), so a mesh over this cap is uniformly decimated (evenly-spaced triangle sampling) — the response's "overlay" field reports the exact ratio kept. > 0
`overlayMode` optional	`enum`	CADSF-1435: how the overlay layer draws — "ghost" (default): alpha-blended, depth-tested but not depth-writing, drawn after the opaque body. "wire": edges only, no fill. one of "ghost", "wire" · default `"ghost"`
`overlayOpacity` optional	`number`	CADSF-1435: the ghost layer's opacity (ignored for {"overlayMode":"wire"}'s line alpha, which uses the same value). Also adjustable live in the viewer. ≥ 0 · ≤ 1 · default `0.35`
`renderer` optional	`enum`	CADSF-416: "three" (default) is the full-featured three.js viewer (pan, wireframe toggle, ~0.65 MB fixed cost). "compact" builds on cad_mesh_payload's own encoder with a small hand-rolled WebGL renderer — no three.js, orbit + zoom + four real B-rep display modes, sub-500 KB even for large parts. one of "three", "compact" · default `"three"`
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`title` optional	`string`	Caption shown in the viewer's corner and the page title. Defaults to the part reference.
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bytes` required	`integer`	—
`format` required	`enum`	— one of "html"
`path` required	`string`	—
`triangles` required	`integer`	—
`display` optional	`enum`	— one of "shaded", "shaded+edges", "hlr", "wireframe"
`overlay` optional	`object`	—
`overlay.decimated`	`boolean`	—
`overlay.distanceComputed`	`boolean`	—
`overlay.keepRatio`	`number`	—
`overlay.originalTriangles`	`integer`	—
`overlay.triangles`	`integer`	—
`renderer` optional	`enum`	— one of "three", "compact"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_tessellate_body` read Tessellate a body

Mesh a body (or the whole active document) at a requested tolerance/level-of-detail and return ONLY its triangle count, vertex count, and bounding box (mm) plus an opaque handle — never the triangle array itself.

Full description

Pass the handle to cad_export_body or cad_preview_body to reuse this exact mesh instead of re-tessellating. Call cad_help({tool:"cad_tessellate_body"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	a document handle length ≥ 1
`healGeometry` optional	`boolean`	Attempt to heal small topol… default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge lon… > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessel… > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer… > 0
`of` optional	`string`	"all" (every live body in t… default `"all"`
`sizing` optional	`object`	Size field (mm): global max…
`sizing.angularCapDeg`	`number`	Normal-deviation cap on cur… > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a th… ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp…
`sizing.growthRatio`	`number`	Max size ratio between neig… ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. > 0
`sizing.hMin`	`number`	HARD floor in mm. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget fo… > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/t…
`sizing.regions`	`object[]`	Refine-here regions: a box… ≤ 32 items
`stream` optional	`boolean`	Needs an MCP progressToken. default `false`
`tolerance` optional	`number`	Chord tolerance in mm: the… > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bbox` required	`object`	—
`bbox.max`	`number[]`	— exactly 3 items
`bbox.min`	`number[]`	— exactly 3 items
`handle` required	`string`	—
`solidIds` required	`string[]`	—
`triangleCount` required	`integer`	—
`vertexCount` required	`integer`	—
`lod` optional	`object`	—
`lod.achievedTriangles`	`integer`	—
`lod.method`	`enum`	— one of "subdivision", "chord-tolerance", "coarsest-achievable"
`lod.requestedMaxTriangles`	`integer`	—
`lod.bandAspectRelaxed`	`boolean`	—
`lod.saturated`	`boolean`	—
`lod.shortfall`	`boolean`	—
`lod.tolerance`	`number`	—
`lodStream` optional	`object`	CADSF-423 streaming report…
`lodStream.streamed`	`boolean`	—
`lodStream.coarse`	`object`	—
`lodStream.final`	`boolean`	True when every body reache…
`lodStream.levels`	`integer`	How many LOD levels this ca…
`lodStream.metaKey`	`string`	The notification params._me…
`lodStream.notifications`	`integer`	Progress notifications emit…
`lodStream.reason`	`string`	Present when streaming was…
`lodStream.solidCount`	`integer`	—
`lodStream.transport`	`string`	"notifications/progress" wh…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_mesh_payload` write Get mesh data in-band for a viewer

Return the tessellated mesh ITSELF on the result's structuredContent.mesh (the text block is only a size summary) so a sandboxed viewer (a Claude artifact, a Cowork preview) can render the part.

Full description

Compact base64 buffers: quantized positions, octahedral normals, indices, per-face groups, B-rep edge polylines, bbox, iso camera. Call cad_help({tool:"cad_mesh_payload"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field — use this to target a document OTHER than the session's default (e.g. a second part built with a modeling call's {"document":"new"}). Omit to use the session's default/active document. length ≥ 1
`edges` optional	`boolean`	Include B-rep edge polylines sampled from the real STEP curves (not triangle boundaries), deduplicated and quantized on the same grid as the positions. Drawing them over the shaded mesh is the difference between a grey blob and a CAD model. Set false if you only need the surface. default `true`
`faceGroups` optional	`boolean`	Include the per-face partition (faces[]: triangle AND vertex ranges keyed by the face id cad_body_topology reports). This is what makes face picking and per-face colouring possible in the viewer. Set false only to save a few hundred bytes on a body you will never click. default `true`
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating.
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`material` optional	`object \| string`	CADSF-1202: a default KHR_materials_pbrMetallicRoughness-shaped material for a bare body (no per-face authored colour), shipped alongside the geometry as payload.material so a viewer can shade the part as machined stock instead of flat grey. Either a named stock ("6061-T6", "ti-6al-4v", "in718", "ss-304", "ss-316", "mild-steel", "brass-c360", "abs", "pla", "pa12", "acrylic" — exporters/materials.js STOCKS has the full table and each colour/roughness citation) or a full {baseColorFactor, metallicFactor, roughnessFactor, name?} object. An unrecognised stock name is refused, listing every known stock. A decoder that has never heard of "material" ignores the field and still gets a fully correct (if flat-shaded) body.
`maxBytes` optional	`integer`	Refuse rather than return an in-band payload larger than this many bytes of JSON (default 262144, ceiling 4194304). The refusal reports the actual size and a suggested maxTriangles that would fit. Ignored when "path" is given. ≥ 1024 · ≤ 4194304 · default `262144`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`normals` optional	`enum`	Vertex normals. "oct8" (default) is octahedral-encoded to 2 bytes/vertex (~1 degree error, the glTF/meshoptimizer scheme); "float32" is 12 bytes/vertex; "none" omits them — use flat shading then, which looks right on planar faces and faceted on curved ones. Normals are area-weighted WITHIN each B-rep face, so edges stay crisp and cylinders stay smooth. one of "oct8", "float32", "none" · default `"oct8"`
`of` optional	`string`	"all" (every live body in the active document, merged) — the default — "<opId>" (body 0 of that op), or "<opId>#<bodyIndex>" (one body of a multi-body op). For format:"step", "all"/omitted still serializes the whole assembled document, but naming ONE body writes a STEP file containing ONLY that body (CADSB-144) — this is what lets two parts in the same document export as two separate STEP files without needing two documents; a "document":"new" modeling-tool call plus this tool's own "document" field is the OTHER way, for two parts you want to keep fully independent. default `"all"`
`path` optional	`string`	Optional .json output path. When given, the payload is WRITTEN there and the response carries only {path, bytes, counts, bbox, camera} — nothing in-band, no size cap. Use this when a viewer can read the filesystem (a Cowork/Claude Code artifact pipeline) and you would rather not spend context on the buffers. Relative paths resolve against the configured output directory.
`positionBits` optional	`integer`	Quantization precision, 8..16 bits per axis (ignored when positionEncoding is "float32"). 16 bits over a 100 mm part is +/-0.0008 mm. 8 or fewer packs one byte per component instead of two — a quarter of the position bytes, at ~0.4% of the model extent of error; good enough for a thumbnail, not for measuring. ≥ 8 · ≤ 16 · default `16`
`positionEncoding` optional	`enum`	How vertex positions are packed. "quantized" (default) stores integers on a uniform grid over the body's bounding box with an affine decode (p = origin + q * scale, the glTF KHR_mesh_quantization convention) — half the bytes of float32 and the payload reports the exact worst-case error in mm as positions.maxErrorMm. "float32" only if you need raw floats. one of "quantized", "float32" · default `"quantized"`
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`stream` optional	`boolean`	Needs an MCP progressToken. Streams LOD progress when the caller sent one (params._meta). No token, no coarse pass; the final result is byte-identical either way. See "lodStream" on the response. default `false`
`strict` optional	`boolean`	CADSF-1377. Multi-body sets only. false/omitted (default): the finishing check's report rides the result as an "assembly" block and anything wrong is a WARNING — the file is still written. true: a part that floats, interpenetrates another part, or does not sit on z=0 (within 0.5 mm, for the parts that reach lowest) REFUSES the call as E_ASSEMBLY_UNSOUND before anything is written, with the same report in details.assembly. Use it as a release gate.
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`uv` optional	`string \| object`	SceneReady uv0 (TEXCOORD_0, metric: 1 uv = 1 m) + uv1 (TEXCOORD_1, packed 0-1 atlas), 1:1 with positions. Omitted: ON unless over the in-band cap (result uv.omitted says so). "game": always. "none": never. Or {tangents?: bool, uvScale?: mm per uv0 unit (1000), atlasPx?: 64..16384 (1024), encoding?: "quantized" (default, 8 B/vertex) \| "float32"} = "game" with options. Format: docs/FORMATS.md.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bytes` required	`integer`	Serialized JSON size of the payload.
`triangleCount` required	`integer`	—
`vertexCount` required	`integer`	—
`assembly` optional	`object`	CADSF-1377 finishing check — present only when the exported set holds MORE THAN ONE body. Connectivity + interference over the exported parts: `warnings[]` is the headline (empty when the assembly is sound), `parts[]` carries per-part touches/penetrates/floating/offFloor/joints. With "strict":true the same report refuses the call as E_ASSEMBLY_UNSOUND instead of warning.
`assembly.bodies`	`integer`	—
`assembly.checked`	`boolean`	false when the check was skipped — `note` says why.
`assembly.counts`	`object`	—
`assembly.findings`	`object[]`	—
`assembly.floorRule`	`object`	—
`assembly.gaps`	`object[]`	CADSF-1376 — pairs that very nearly touch but do not: {a, b, distance, kind} in mm, nearest first, for every pair under the gap threshold (default 1 mm). A joint modelled a fraction of a millimetre short is the error `floating` cannot see. Omitted from an export envelope when non-empty, exactly as interference[] is; counts.gaps has the number.
`assembly.interference`	`object[]`	CADSF-1376 — one row per INTERFERING PAIR: {a, b, volume} in mm^3. The pairwise view of the same penetrations parts[].penetrates carries per part; empty is the pass condition. On an EXPORT envelope the rows are omitted when there are any (counts.interferingPairs has the number, and the warnings name the pairs) — cad_design_review {"kind":"assembly"} returns them.
`assembly.ms`	`number`	—
`assembly.note`	`string`	—
`assembly.parts`	`object[]`	—
`assembly.unfastened`	`object[]`	CADSF-1576 — LOAD-BEARING CONTACTS WITH NOTHING THROUGH THEM: {a, b, area} in mm^2, widest first, for every pair whose planar contact is at or above 100 mm^2 and which no cad_joint / cad_fastener record names and no hardware body bridges. A stated fixing is MODELLED: two parts merely in contact are an assembly that has not been fastened yet. Reported, never a refusal — counts.unfastenedContacts has the number, and the rows are omitted from an export envelope exactly as interference[] and gaps[] are.
`assembly.units`	`object`	—
`assembly.warnings`	`string[]`	—
`bbox` optional	`object`	—
`bbox.max`	`number[]`	— exactly 3 items
`bbox.min`	`number[]`	— exactly 3 items
`camera` optional	`object`	—
`edgeCount` optional	`integer`	—
`faceCount` optional	`integer`	—
`handle` optional	`string`	—
`lod` optional	`object`	—
`lod.achievedTriangles`	`integer`	—
`lod.method`	`enum`	— one of "subdivision", "chord-tolerance", "coarsest-achievable"
`lod.requestedMaxTriangles`	`integer`	—
`lod.bandAspectRelaxed`	`boolean`	—
`lod.saturated`	`boolean`	—
`lod.shortfall`	`boolean`	—
`lod.tolerance`	`number`	—
`lodStream` optional	`object`	CADSF-423 streaming report: whether LOD levels were pushed over notifications/progress, and if not, why not.
`lodStream.streamed`	`boolean`	—
`lodStream.coarse`	`object`	—
`lodStream.final`	`boolean`	True when every body reached the requested resolution.
`lodStream.levels`	`integer`	How many LOD levels this call defines (coarse + final).
`lodStream.metaKey`	`string`	The notification params._meta key the structured level rides on.
`lodStream.notifications`	`integer`	Progress notifications emitted for this call.
`lodStream.reason`	`string`	Present when streaming was declined — says exactly why.
`lodStream.solidCount`	`integer`	—
`lodStream.transport`	`string`	"notifications/progress" when streamed, "none" otherwise.
`mesh` optional	`object`	The payload itself (format "cadsolver.mesh/2"); absent when "path" was given. Full schema: cadsolver://schema/mesh-payload.
`path` optional	`string`	—
`solidIds` optional	`string[]`	—
`uv` optional	`object`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_design_knowledge` write DFM knowledge packs — the numbers for a product type

BEFORE MODELLING A NAMED PRODUCT, look it up here.

Full description

Call cad_help({tool:"cad_design_knowledge"}) for the rest.

Argument	Type	Meaning & bounds
`action` required	`enum`	— one of "list", "load", "search", "laminate", "record"
`kinds` optional	`enum[]`	search only: restrict to these entry kinds.
`laminate` optional	`object`	—
`limit` optional	`integer`	search only: max rows (default 10). ≥ 1 · ≤ 50
`maxEntries` optional	`integer`	load only: page size in entries (default 40). ≥ 1 · ≤ 500
`offset` optional	`integer`	load only: first entry of the page (default 0). ≥ 0
`query` optional	`string`	search only: the user's own words.
`rule` optional	`any`	—
`sectors` optional	`string[]`	Pack ids, sector words or aliases…
`size` optional	`enum`	How much of a pack: core… one of "core", "standard", "full"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_interfaces` read Extract mating interfaces (hole patterns, connectors, mount faces)

Read a part's CONNECTION POINTS off its B-rep as JSON, each with a mating frame {origin, zAxis, xAxis, yAxis} (mm, world frame; maps 1:1 to an Onshape mate connector: origin, primary axis Z, secondary X).

Full description

Call cad_help({tool:"cad_interfaces"}) for the rest.

Argument	Type	Meaning & bounds
`detail` optional	`enum`	full: per-hole records + positions. one of "summary", "full"
`file` optional	`string`	STEP path (relative: outputDirectory). length ≥ 1
`include` optional	`enum[]`	Sections to return. Default all.
`minHoleDiameter` optional	`number`	Skip holes under this diameter, mm. Default 1. ≥ 0
`solid` optional	`string`	Or: a session body handle. length ≥ 1
`tolerance` optional	`number`	Pattern tolerance, mm. Default 0.01. > 0 · ≤ 1
`units` optional	`string`	With file: length unit override (mm, in, ...).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

GD&T and PMI · 4

Tolerancing carried on the model rather than in a note: datum features, the 14 Y14.5 characteristics with their modifiers and datum reference frames, and dimensional tolerances — authored against real faces and edges, validated as they are built, and exported as semantic AP242 PMI.

`cad_pmi_author` write Author a datum, feature control frame or dimensional tolerance

Put GD&T on the model itself.

Full description

ONE call authors ONE annotation against the faces/edges of a body already built in this session, and the set is carried on the document so cad_export_body writes it into the STEP file as SEMANTIC AP242 PMI — the same entities this kernel's own reader recovers, not a drawing note. Call cad_help({tool:"cad_pmi_author"}) for the rest.

Argument	Type	Meaning & bounds
`kind` required	`enum`	"fcf" is a feature control frame. one of "datum", "fcf", "dimension", "auto"
`solid` required	`string`	Body handle from this session.
`characteristic` optional	`enum`	kind "fcf" only: the characteristic. one of "straightness", "flatness", "circularity", "cylindricity", "profileOfALine", "profileOfASurface", "angularity", "perpendicularity", "parallelism", "position", "concentricity", "coaxiality", "symmetry", "circularRunout", "totalRunout"
`datumRefs` optional	`object[]`	kind "fcf" only: datums, primary first.
`description` optional	`string`	kind "fcf" only: optional free-text note.
`label` optional	`string`	kind "datum" only: the datum letter.
`lower` optional	`number`	kind "dimension" only: lower deviation, SIGNED.
`measure` optional	`enum`	kind "dimension" only: what the dimension IS. one of "linear", "diameter", "radius", "angular"
`minus` optional	`number`	kind "dimension" only: lower deviation magnitude.
`modifiers` optional	`enum[]`	kind "fcf" only: tolerance modifiers.
`name` optional	`string`	Optional human name for this annotation.
`nominal` optional	`number`	kind "dimension" only: nominal, mm or degrees.
`plus` optional	`number`	kind "dimension" only: upper deviation, signed.
`process` optional	`string`	kind "auto": process, cnc default.
`replace` optional	`boolean`	kind "auto": replace PMI on the body.
`symmetric` optional	`number`	kind "dimension" only: the ± half-band. > 0
`targets` optional	`object[]`	Face/edge ids from cad_body_topology. ≥ 1 items
`upper` optional	`number`	kind "dimension" only: upper deviation, SIGNED.
`value` optional	`number`	kind "fcf" only: zone size in mm. > 0
`zone` optional	`enum`	kind "fcf" only: "diameter" = a Ø zone. one of "diameter"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_pmi_list` read List the PMI authored on a body

Read back every datum, feature control frame and dimensional tolerance authored on a body — with the id cad_pmi_remove takes, the callout text as it would be read off a print, and three things an agent cannot otherwise find out.

Full description

Call cad_help({tool:"cad_pmi_list"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	id or "<id>#<n>"
`target` optional	`string`	Optional: list only the annotations attached to…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_pmi_remove` destructive Remove one authored PMI annotation

Remove one datum, feature control frame or dimensional tolerance from a body BY ID — the id cad_pmi_author returned and cad_pmi_list reports.

Full description

By id and not by description, so "remove the perpendicularity frame" cannot take the wrong one of two. Call cad_help({tool:"cad_pmi_remove"}) for the rest.

Argument	Type	Meaning & bounds
`id` required	`string`	The annotation id from cad_pmi_author's respons…
`solid` required	`string`	Body handle already built in the active session.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_gdt_position` read Position tolerance from the fastener + MMC/LMC min-wall check

Size a hole pattern's position tolerance from its fastener (ASME Y14.5: floating T = H − F, fixed T1 + T2 = H − F), check a stated zone against it, and/or check that the Ⓜ/Ⓛ bonus zone keeps a minimum wall (bonus_breaks_min_wall names both diameters).

Full description

Pure arithmetic in your unit; no body.

Argument	Type	Meaning & bounds
`clearanceShare` optional	`number`	fixed only: fraction of H − F given to the cl… > 0 · < 1
`condition` optional	`enum`	floating = bolt + nut, clearance holes in both… one of "floating", "fixed"
`engagement` optional	`number`	D: min thread engagement depth. > 0
`fastenerDia` optional	`number`	F: fastener major Ø at MMC. > 0
`features` optional	`object[]`	Features whose zones bound a wall: {id, type… ≥ 1 items · ≤ 256 items
`holeLmc` optional	`number`	Clearance hole Ø at LMC (largest) — adds the… > 0
`holeMmc` optional	`number`	H: clearance hole Ø at MMC (smallest). > 0
`metric` optional	`object`	ISO metric fastener instead of fastenerDia: F =…
`metric.d`	`number`	— > 0
`metric.grade`	`enum`	— one of "fine", "medium", "coarse"
`minWall` optional	`number`	Required minimum wall for the min-wall check. ≥ 0
`part` optional	`enum`	Which part "stated" belongs to: 0 clearance… one of 0, 1
`precision` optional	`integer`	Callout decimals, tolerances rounded DOWN… ≥ 0 · ≤ 6
`projected` optional	`boolean`	fixed only: true (default) = projected zone Ⓟ…
`projection` optional	`number`	P: max fastener projection… > 0
`stated` optional	`number`	A stated position zone (at MMC) to check agains… ≥ 0
`unit` optional	`enum`	Printing only (".005" vs "0.005"); every number… one of "mm", "in"
`walls` optional	`object[]`	Walls to check: {between:[idA,idB], spacing?}… ≥ 1 items · ≤ 1024 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Assemblies · 9

More than one part: reading a STEP assembly structure, solving mates over built bodies, checking a shaft/bore fit, reporting which faces actually touch before anything is analysed, and rolling the whole thing up into a bill of materials.

`cad_assembly_import` write Read a STEP file's assembly structure

Read a STEP file's PRODUCT STRUCTURE — its NEXT_ASSEMBLY_USAGE_OCCURRENCE graph — and return the component hierarchy: how many components, how they are nested, what each occurrence is called, and the fixed/floating state of every component in the mate set.

Full description

Call cad_help({tool:"cad_assembly_import"}) for the rest.

Argument	Type	Meaning & bounds
`file` required	`string`	Path to a STEP (AP203/AP214/AP242) file. length ≥ 1
`document` optional	`string`	Which session document to publish into…
`maxNodes` optional	`integer`	Cap on the number of tree nodes returned… ≥ 1 · ≤ 400
`publish` optional	`boolean`	Also BUILD the assembly into the session: one b…
`publishMode` optional	`enum`	What "publish" builds: "occurrences" (default)… one of "occurrences", "parts"
`units` optional	`string`	Override the file's own length-unit declaration…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_mate` read Build and solve a mate set over already-built bodies (assembly instance placement)

Given two or more already-built bodies as named "components" and a list of MATES between their faces (concentric, coincident, distance, angle, parallel, perpendicular, tangent, lock — AssemblyMates.js's full vocabulary), solve for where every ungrounded component must sit so all the mates are satisfied, and report it.

Full description

Call cad_help({tool:"cad_assembly_mate"}) for the rest.

Argument	Type	Meaning & bounds
`components` required	`object[]`	— ≥ 2 items · ≤ 32 items
`mates` required	`object[]`	— ≥ 1 items · ≤ 64 items
`acceptTol` optional	`number`	Residual norm below which the solve counts as c… ≥ 0
`ground` optional	`string[]`	Component names to ground, as an alternative to…
`maxIter` optional	`integer`	Solver iteration cap… ≥ 1 · ≤ 2000

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_fit` read Check a shaft/bore diametral fit, or a planar face-pair fit (clearance, coaxiality/parallelism, interference)

Given TWO faces, one on each of two bodies already built in the active session, measure the fit between them.

Full description

Two modes, chosen automatically from the faces' own surface type: ROUND (both CYLINDRICAL_SURFACE) reports diametral clearance, "coaxial", and "minRadialGap" (worst-case radial gap once the measured axis offset eats into the nominal clearance). PLANAR (both PLANE, parallel) reports "gap" (signed normal distance at the overlap centroid), "overlapArea", and "minGap"/"maxGap" over the overlap footprint's own vertices — minRadialGap's planar analogue; "interferes" is minGap < 0 for an opposite-facing pair. A non-parallel or non-overlapping planar pair, or a CYLINDRICAL/PLANE mismatch, is refused by name. KEYED JOINT (ROUND mode, automatic): when the shaft carries a keyway and the hub a keyseat on the mated walls, "keyedJoint" reports each pair — shaft t1 + hub t2 − key height h against the key table's required clearance (BS 4235-1:1972 / DIN 6885-1:1968), axial engagement and angular offset — and a failing key is a finding; null on an unkeyed fit. READ-ONLY: publishes no body, mutates nothing.

Argument	Type	Meaning & bounds
`boreFace` required	`string`	A "faceId" from cad_body_topology on boreSolid… length ≥ 1
`boreSolid` required	`string`	The other body — must resolve to the SAME doc… length ≥ 1
`shaftFace` required	`string`	A "faceId" from cad_body_topology on shaftSolid… length ≥ 1
`shaftSolid` required	`string`	One body already built in the active session… length ≥ 1
`axisAngleTol` optional	`number`	ROUND mode. ≥ 0
`axisOffsetTol` optional	`number`	ROUND mode. ≥ 0
`keyStandard` optional	`enum`	ROUND mode, keyedJoint only. one of "BS4235", "DIN6885"
`parallelTol` optional	`number`	PLANAR mode. ≥ 0
`requireOppositeFacing` optional	`boolean`	PLANAR mode.
`transitionTol` optional	`number`	ROUND mode. ≥ 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_bom` read Bill of materials for a STEP assembly

Bill of materials for a STEP assembly: one row per unique PART NUMBER (STEP PRODUCT.id) with the quantity summed across every sub-assembly that uses it — a part used directly under the root AND nested inside a sub-assembly reused twice sums into ONE row, not two.

Full description

Call cad_help({tool:"cad_assembly_bom"}) for the rest.

Argument	Type	Meaning & bounds
`csvPath` optional	`string`	Write the FLAT parts list to this path as CSV. length ≥ 1
`density` optional	`number`	Uniform density applied to every part's volume… > 0
`document` optional	`string`	Which session document to roll up…
`file` optional	`string`	Path to a STEP (AP203/AP214/AP242) assembly file. length ≥ 1
`massProperties` optional	`boolean`	Compute per-part volume/mass…
`maxRows` optional	`integer`	Cap on the rows returned per view (default 500). ≥ 1 · ≤ 500
`structured` optional	`boolean`	Also return the indented, one-row-per-occurrenc…
`units` optional	`string`	Override the file's own length-unit declaration…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_contacts` read Face-pair contact set of a STEP assembly

WHICH FACES TOUCH, and by how much — the pre-flight a multi-body model owes any downstream analysis, because a solver bonds whatever touches and welds nothing that does not.

Full description

Call cad_help({tool:"cad_assembly_contacts"}) for the rest.

Argument	Type	Meaning & bounds
`file` required	`string`	STEP file (or a .glb). length ≥ 1
`coincident` optional	`boolean \| object`	Z-fight check.
`fits` optional	`object`	cad_joint fits.
`includePolygons` optional	`boolean`	Overlap hull rings.
`maxClearance` optional	`number`	Report window, mm (default 1). > 0
`maxRows` optional	`integer`	Rows cap per kind (default 50) ≥ 1 · ≤ 200
`minArea` optional	`number`	Min planar overlap, mm^2 (default 1e-4). ≥ 0
`tol` optional	`number`	Touch tolerance, mm (default 0.001). > 0
`unbondedOnly` optional	`boolean`	Unbonded list only.
`units` optional	`string`	Unit override (mm, cm, m, in, ft).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_flowpath` read Flow-path audit: every tube end mates a port or is a declared terminal; no plenum has daylight

DOES EVERY TUBE CARRY WHAT IT IS SUPPOSED TO? Declare the flow path of a piped assembly built in the active session — every tube and plenum with its ports (centre, outward normal, inner radius, and whether the port is a system inlet/outlet, a joint, or an opening into a named plenum) — and the kernel checks it.

Full description

Call cad_help({tool:"cad_assembly_flowpath"}) for the rest.

Argument	Type	Meaning & bounds
`segments` required	`object[]`	The declared flow path. ≥ 1 items · ≤ 256 items
`angleTol` optional	`number`	Joint port normals must be anti-parallel within… > 0
`expected` optional	`object`	How many inlet / outlet terminals the system sh…
`expected.inlets`	`integer`	— ≥ 0
`expected.outlets`	`integer`	— ≥ 0
`maxFindings` optional	`integer`	Cap on findings returned (default 200); counts… ≥ 1 · ≤ 200
`posTol` optional	`number`	Two ports closer than this (mm) are the same jo… > 0
`radiusTol` optional	`number`	Joint port radii must agree within this… ≥ 0
`rays` optional	`integer`	Directions over the sphere per plenum for the m… ≥ 8 · ≤ 2000
`walls` optional	`string[]`	Session bodies the fluid is contained by, for t… ≤ 256 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_assembly_sweep` write Sweep a declared mechanism: min clearance over the motion, transmission/toggle, checks at every pose, end states + scrub

Declare a mechanism ONCE — revolute/prismatic joints (the hinge axes cad_joint builds and the pin centres cad_assembly_mate solves), loop closures, one driving parameter with its range, the end stops and named poses — over already-built bodies (each "component" rides a link; unlisted links are ground), and check the…

Full description

WHOLE motio… Call cad_help({tool:"cad_assembly_sweep"}) for the rest.

Argument	Type	Meaning & bounds
`components` required	`object[]`	— ≥ 2 items
`mechanism` required	`object`	Declared once, in the AS-BU…
`mechanism.driver`	`object`	ONE driver; driven joint =…
`mechanism.joints`	`object[]`	A TREE: each moving link is… ≥ 1 items
`mechanism.closures`	`object[]`	Loop pins: `point` stays co…
`mechanism.name`	`string`	—
`mechanism.poses`	`object`	e.g. {"neutral":0,"full_up"…
`mechanism.stops`	`object[]`	—
`capMm` optional	`number`	Farther pairs are only coun… > 0
`checks` optional	`object`	Per-pose checks.
`checks.access`	`object`	{tools:[{name, point, axis…
`checks.coincident`	`boolean \| object`	true or {tol, angleDeg, min…
`checks.contacts`	`boolean \| object`	—
`checks.count`	`integer`	— ≥ 2 · ≤ 181
`checks.oml`	`object`	{envelope:[bodies], members…
`checks.poses`	`string \| array`	"sweep" (default: `count` u…
`confirm` optional	`boolean`	Analytic check of worst pos…
`exclude` optional	`string[][]`	—
`export` optional	`object`	Writes <basename>_min/_max/…
`export.basename`	`string`	—
`export.dir`	`string`	—
`export.durationS`	`number`	— > 0
`export.frames`	`integer`	— ≥ 2 · ≤ 721
`only` optional	`string[][]`	—
`pressFits` optional	`string[][]`	Declared fits…
`resolutionMm` optional	`number`	Default 0.02. > 0
`runningFits` optional	`object[]`	One joint's bodies…
`sampling` optional	`string \| object`	"adaptive" (default) or {co…
`tightMm` optional	`number`	Default 0.5. ≥ 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_scan_to_sim` write Scan to simulation: a room scan (.ply) in, an articulated assembly out as MJCF, URDF, STEP and assembly.json

Reconstruct a ROOM from a scan and write a model a robot can use in a simulator.

Full description

Input: a .ply point cloud (ascii or binary, as LiDAR and photogrammetry tools export it) or a .ply mesh, in metres (a cloud over 100 units across is read as millimetres and says so). Call cad_help({tool:"cad_scan_to_sim"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`string`	The scan: a .ply point cloud or mesh. length ≥ 1
`complete` optional	`boolean`	Close the room with an assumed ADA entrance…
`formats` optional	`enum[]`	Default all; STEP for the highest level only. ≥ 1 items
`importLevel` optional	`integer`	Load this level's STEP into the session… ≥ 0 · ≤ 4
`lods` optional	`integer[]`	Levels to write (default [0,1,2,3,4]). ≥ 1 items · ≤ 5 items
`outDir` optional	`string`	Where the files go…
`params` optional	`boolean`	Include the full fitted parameter set…
`sim` optional	`boolean`	Exercise every model in MuJoCo + PyBullet…
`units` optional	`enum`	Default auto. one of "auto", "m", "mm"
`voxel` optional	`number`	Down-sample voxel, metres (default 0.015). ≥ 0.005 · ≤ 0.1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fastener_audit` read Is every fastener in the live document SEATED?

IS EVERY FASTENER SEATED, or merely placed? Measures each against the other bodies and answers by code: does the head BEAR or stand off, is the SHANK in a hole, buried, or in air, how far is it ENGAGED, how far does it PROTRUDE, is it TILTED to its hole, is a nut on nothing.

Full description

Call cad_help({tool:"cad_fastener_audit"}) for the rest.

Argument	Type	Meaning & bounds
`bodies` optional	`string[]`	Body handles to measure the fasteners AGAINST.
`document` optional	`string`	Document handle to audit (e.g. "doc_1").
`documents` optional	`string[]`	Several live documents to audit TOGETHER, in wo…
`fasteners` optional	`object[]`	Audit these fasteners instead of the document's…
`hardware` optional	`string[]`	CADSF-102137: body handles that ARE fasteners…
`inserts` optional	`string[]`	CADSF-102137: body handles that are INSERTS or…
`maxRows` optional	`integer`	Cap on findings and per-fastener rows returned… ≥ 1 · ≤ 200
`rules` optional	`object`	Tolerance overrides.
`rules.bearTol`	`number`	How far below the head underside a face still c… ≥ 0
`rules.chord`	`number`	Tessellation chord tolerance in mm (default 0.3). > 0
`rules.flangeMinWall`	`number`	Wall that must remain outside an insert / flang…
`rules.headUncutTol`	`number`	Host material inside the head volume that is he… ≥ 0
`rules.holeSlack`	`number`	How far past the hole radius a wall still count… ≥ 0
`rules.insertOverlapMm3`	`number`	Insert / host overlap that is insert-inside-hos… ≥ 0
`rules.material`	`string`	Engagement family for a landing body that decla…
`rules.modelledSolids`	`boolean`	CADSF-102137: false = the radial probes only…
`rules.protrusionPitches`	`number`	Shank allowed past the last clamped part, in th… ≥ 0
`rules.shankSolidTol`	`number`	Host material inside the shank span that is a s… ≥ 0
`rules.socketClearMm`	`number`	Straight room a socket needs off a nut's free f… ≥ 0
`rules.stationStep`	`number`	Spacing of the dense engagement/protrusion scan… > 0
`rules.tiltDeg`	`number`	Hole-axis vs shank-axis angle that becomes a fi… > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Manufacturing review & simulation · 16

The checks that catch a part before a vendor does: DFM rules, moldability, a whole-design review, an aerodynamic pass over the shape, and a stress or modal case solved with CalculiX or MYSTRAN, and a topology optimisation that finds the lightest shape carrying the loads.

`cad_dfm_check` read DFM / validity check

Validity check (tier "local"|"full"); "process" adds its DFM pack: machining, molding, sheet, additive or vendor pack; route "scs_laser+scs_bend" gets the binding limit.

Full description

"approved" gates review; "params" = knobs; maxIssues pages. Call cad_help({tool:"cad_dfm_check"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	a solid id already built in this session (a document op's "id", or "<opId>#<bodyIndex>") length ≥ 1
`analytic` optional	`object`	optional known-good volume/area to cross-check against (full tier only)
`analytic.area`	`number`	—
`analytic.volume`	`number`	—
`drain` optional	`object`	FLOW-DRAIN: flag fluid trapped below every outlet invert (a sump). outlets: [{point (invert) \| faceId, radius}]; gravity or orientations (depowder); fluid: domain body.
`drain.outlets`	`object[]`	— ≥ 1 items · ≤ 16 items
`drain.fluid`	`string`	— length ≥ 1
`drain.gravity`	`number[]`	— exactly 3 items
`drain.orientations`	`number[][]`	— ≥ 1 items · ≤ 8 items
`drain.resolution`	`integer`	— ≥ 16 · ≤ 600
`drain.tolerance`	`number`	— ≥ 0
`issueOffset` optional	`integer`	With maxIssues: skip this many grouped rows first — page via a prior response's page.nextOffset. ≥ 0 · default `0`
`maxIssues` optional	`integer`	Group findings by rule ({severity,reasonCode}, with a `count`) and cap the rows returned to this many; adds `truncated`/`page`. Omit for the full unbounded list. ≥ 1
`pack` optional	`any`	Alias of "process" (one pack name, a "+"-joined route, or an array). "process" wins when both are given.
`params` optional	`object`	process parameters the pack's derived limits are computed from; every key defaults to the pack's own value
`params.alloy`	`string`	foundrylab_dmc: the alloy being cast ("al", "zn", "mg", "cu"/"bronze"/"brass" pass; "stainless" is flagged coming; steel, iron and titanium are refused) length ≥ 1
`params.amsCompatible`	`boolean`	fdm_x1c: this filament can run through the AMS (false for TPU and other soft filaments) — drives x1c_ams_tpu
`params.amsSlots`	`object[]`	fdm_x1c: [{ slot, material }] — the AMS filament mapping. A soft filament (TPU) in a slot is a refusal: it must run from the external spool
`params.availableBendRadii`	`number[]`	scs_bend: the inside bend radii this shop actually tools for this material, mm — a shop with fixed tooling has a LIST, not a range. Filled from every stocked gauge of the catalog material; bend_radius_available checks against it
`params.axes`	`integer`	ded: machine axes — >= 5 tilts (overhangs become ded_overhang_tilt info); default from the record's process text, else 3 ≥ 3 · ≤ 9
`params.axisymmetryToleranceDeg`	`number`	turning: how far a face normal may lean out of the (axis, radius) plane before the face counts as milled rather than turned, degrees (default 15) > 0
`params.ballMillRadii`	`number[]`	scs_mill: stocked ball end-mill radii, mm — internal fillets off this list are flagged as un-tool-matched ≥ 1 items · ≤ 64 items
`params.beadWidth`	`number`	ded: bead width, mm — the one-bead min wall; overrides the process figure > 0
`params.bedExcludeArea`	`object`	fdm_x1c: the refused rectangle in plate coordinates (default the X1C profile's front-left 0..18 x 0..28 mm bed_exclude_area)
`params.bedPlacement`	`array \| string`	fdm_x1c: where the part sits on the plate — "centred" (what the slicer does on import, the default), "as-modelled" (the body's own coordinates read as bed coordinates), or [x, y] placing the footprint's min corner
`params.bendRadius`	`number`	scs_bend: the shop's FIXED inside bend radius for this material + thickness, mm (SendCutSend offers no custom radius — read it off their bending calculator) > 0
`params.bendRadiusTolerance`	`number`	scs_bend: tolerance on the fixed bend radius, mm (default max(0.05, 2% of bendRadius)) > 0
`params.brimMm`	`number`	fdm_x1c: brim width this filament wants, mm — quoted as the warping remedy ≥ 0
`params.buildDirection`	`number[]`	additive packs (fdm/sla/sls/mjf/dmls): build/print direction (default [0,0,1]) — drives max_overhang_angle exactly 3 items
`params.buildVolumeMm`	`number[]`	foundrylab_dmc: build volume X,Y,Z, mm (provisional default 304.8 cube = 1 ft^3) exactly 3 items
`params.catalogRow`	`object`	scs_bend: DERIVED, not a setting — the data/scs/catalog.json row that was applied (material, thickness, capturedAt, snapshot hash, per-field provenance). Populated by resolvePack when params.material names a catalog row, and quoted by every catalog-driven verdict so a report can say which table decided. Passing it yourself only relabels the citation
`params.chamberC`	`number`	fdm_x1c: chamber temperature this filament wants, C (null for the ones that do not) — quoted as the warping remedy ≥ 0
`params.colourPlan`	`object`	fdm_x1c: { slabHeight, filaments: [{ id, colour: "light"\|"dark"\|"clear", zRange: [lo, hi] }] } — drives the multi-colour purge/prime-tower cost estimate
`params.cupMinArea`	`number`	resin: pocket floor area above which resin_suction_cup warns, mm2 (25) ≥ 0
`params.cutterDiameter`	`number`	machining: end-mill diameter, mm — drives the internal-corner-radius limit (>= 0.6 x cutterDiameter) > 0
`params.density`	`number`	fdm_x1c: filament density, g/cm3, as Bambu write it in filament_density — turns purge volume into grams > 0
`params.depositionProcess`	`enum`	ded: deposition process — selects the bead model; default from the printer record (technology / tech) one of "ded_powder", "ded_wire", "waam", "ebam"
`params.dieWidth`	`number`	oshcut_bend / scs_bend: V-die opening, mm — the die contact band is half of this either side of the bend line (default 8 x materialThickness, the standard air-bending vee) > 0
`params.drainHoleCount`	`integer`	resin: drain holes each cavity needs (2: one lets resin out, one lets air in) ≥ 1
`params.drainHoleMin`	`number`	resin: smallest drain hole that drains, mm (3.5) — resin_hollow_drain > 0
`params.drainOutlets`	`object[]`	drainability: the declared outlet bore(s) of the internal fluid volume(s). Each is { a, b, r } (a segment spanning the bore from the cavity to past its outer mouth, radius mm) or { faceId } of a cylindrical bore face. Liquid that reaches an outlet leaves; liquid held below the lowest outlet invert after drain-down is measured in mL against rules.drainability.limit (default 0) ≥ 1 items · ≤ 32 items
`params.drainPlugs`	`object[]`	drainability: every OTHER opening of the fluid volume (inlet ports, vents, sensor bores), same shape as drainOutlets — closed while the part drains, so the fluid volume is a closed cavity whose only exits are the outlets ≤ 64 items
`params.drainVoxel`	`number`	drainability: voxel size, mm (default min(part size / 150, smallest port radius / 2.5), coarsened with a warning past 12M voxels). Pockets shallower than one voxel are not reported > 0
`params.elephantFootCompensation`	`number`	fdm_x1c: elefant_foot_compensation, mm (profile default 0.15) ≥ 0
`params.externalCornerRadii`	`number[]`	scs_mill: stocked external corner radii, mm ≥ 1 items · ≤ 64 items
`params.extrusionWidth`	`number`	fdm/additive: nozzle extrusion width, mm — drives the min wall limit (2 x extrusionWidth) > 0
`params.fits`	`object[]`	fdm_x1c: [{ name, class: "press"\|"sliding"\|"hinge"\|"loose", clearance }] — from cad_tolerance_stack or cad_assembly_contacts
`params.flangeMm`	`number`	foundrylab_dmc: flange / bolt-boss margin per side for the envelope check, mm (provisional default 15) ≥ 0
`params.footprintGapMm`	`number`	foundrylab_dmc: clearance between moulds when counting moulds per build, mm (provisional default 5) ≥ 0
`params.furnaceMaxC`	`number`	foundrylab_dmc: furnace ceiling, C (provisional default 1093 = 2000 F) > 0
`params.gaugingEdgeLength`	`number`	oshcut_bend: minimum length of a flat edge parallel to the bend line for the backgauge to square against, mm (default 6.35 = OSH Cut's published 0.25 in) > 0
`params.gearAnalytic`	`object`	singular convenience for gearTeeth: one gear descriptor instead of an array
`params.gearTeeth`	`object[]`	fdm_x1c (and any pack sharing ops/dfmRules.js's min_wall_thickness): gears this body carries, graded on their own tip land rather than the generic wall probe. See ops/gear.js gear()/gearGeometry()'s `analytic` block
`params.gravity`	`number[]`	drainability: the direction liquid falls in the INSTALLED orientation, body coordinates (default [0,0,-1]) exactly 3 items
`params.greenScale`	`number[]`	metal_fff: green oversize scale X,Y,Z (Ultrafuse 1.2,1.2,1.24); default from the vendor family, else not checked exactly 3 items
`params.holeCompensation`	`number`	fdm_x1c: xy_hole_compensation, mm. Bambu ship 0, which is why x1c_hole_compensation fires on vertical holes; a non-zero value silences it ≥ 0
`params.host`	`string`	metal_fff: a desktop FDM printer id/alias that prints Ultrafuse filament; its bed bounds the green part (also capped at 100 mm by the debind/sinter plate)
`params.kFactor`	`number`	scs_bend: the shop's fixed K-factor for this material — carried on the pack for flat-pattern work; not itself a geometric check
`params.kerfWidth`	`number`	scs_laser: beam kerf width, mm — the minimum internal corner radius a laser can cut > 0
`params.layerHeight`	`number`	fdm_x1c: layer height, mm — checked against the range the profile publishes for the fitted nozzle > 0
`params.loadAxis`	`number[]`	fdm_x1c: the direction the part is loaded in. A load off the build axis takes x1c_z_anisotropy out of play, since the layer-bond weak axis is then not the loaded one exactly 3 items
`params.machiningStock`	`number`	ded: machining stock on every functional face, mm; overrides the process figure > 0
`params.machiningStockMm`	`number`	cold_spray / metal_jetting / moldjet / metal_dlp: machining stock reserved on every face, mm, subtracted from the build envelope (no public allowance, so none is assumed) > 0
`params.material`	`string`	oshcut_laser / scs_laser / scs_router: the material family being cut ("mild-steel", "stainless-steel", "aluminum", "copper", "brass", "bronze", "nickel", or an alias such as "304"/"6061"/"C110"). Applies that row's stocked thickness range on top of the shop-wide limits; anything you also pass explicitly wins. Omit and the pack uses the WIDEST published range and says so. lpbf / lpbf_printer: an LPBF alloy (Ti-6Al-4V, 316L, 17-4PH, IN718, IN625, AlSi10Mg, Scalmalloy, CuCrZr, GRCop-42, maraging, CoCr — or a registry spelling such as "Ni718"); applies that row's sourced limits and says where a figure is unverified. fictiv_mill (no catalog): "metal" (default) or "plastic" — selects the published minimum machined wall (0.8 mm vs 1.5 mm) length ≥ 1
`params.materialThickness`	`number`	sheet metal: sheet thickness, mm — drives the min hole diameter and corner radius limits > 0
`params.maxBendLength`	`number`	scs_bend: longest bend the brake will run for this material and thickness, mm (SendCutSend publish 16-44 in depending on both). Carried on the pack; no geometric rule enforces it yet > 0
`params.maxPartSize`	`number[]`	maximum part size, mm, ascending (e.g. scs_mill [177.8, 177.8, 304.8] = 7in x 7in x 12in) ≥ 1 items · ≤ 64 items
`params.maxSectionRatio`	`number`	investment_casting: maximum ratio between the thickest and thinnest sampled section, x — drives max_section_ratio (default 6) > 0
`params.maxSwingDiameter`	`number`	turning: the lathe's swing, mm — the largest turned diameter that clears the bed > 0
`params.maxTurnedLength`	`number`	turning: distance between centres, mm — the longest part the machine holds > 0
`params.minCoredHoleMm`	`number`	foundrylab_dmc: minimum cored hole diameter, mm (provisional default 3) > 0
`params.minDraftDeg`	`number`	foundrylab_dmc: minimum draft on pull faces, deg (provisional default 1) ≥ 0
`params.minFeature`	`number`	resin: free-standing pin/wire floor, mm (sla 0.3, msla 0.5) — resin_min_feature > 0
`params.minFilletMm`	`number`	investment_casting: minimum internal (concave) fillet radius on the casting pattern, mm — drives min_fillet_radius (default 0.5 mm) > 0
`params.minFlange`	`number`	oshcut_bend / scs_bend: minimum flange length measured from the bend tangent, mm — both shops publish it per material in their catalogs (default dieWidth/2 + materialThickness) > 0
`params.minHole`	`number`	resin: smallest hole that stays open, mm (0.5) > 0
`params.minHoleToBend`	`number`	scs_bend: minimum distance from a hole edge to the CENTRELINE of a bend, mm. SendCutSend publish it as half the die width ("keep cut features at least half the die's width away from the bend line"); filled per material + thickness from data/scs/catalog.json when params.material names a row > 0
`params.minInternalRadius`	`number`	scs_mill: the shop's published absolute minimum internal corner radius, mm — the limit is max(this, 0.6 x cutterDiameter) ≥ 0
`params.minPartSize`	`number[]`	minimum part size, mm, ascending. TWO values are a sheet bound applied to the part's two largest dimensions; THREE bound all three (e.g. scs_router [25.4, 50.8] = 1in x 2in) ≥ 1 items · ≤ 64 items
`params.minSeamGap`	`number`	oshcut_bend / scs_bend: minimum clearance where two flanges meet at a seam, mm (default one materialThickness — the allowance for springback) > 0
`params.minSectionMm`	`number`	investment_casting: minimum castable section (wall) thickness, mm — drives min_section (default 1.0 mm for a nickel-superalloy aerofoil at blade scale) > 0
`params.minTurnedDiameter`	`number`	turning: the smallest bar this route runs, mm > 0
`params.minWallFloor`	`number`	fdm_x1c: a filament-specific wall floor, mm, that overrides the 2 x line width one (filled filaments: 1.2) > 0
`params.minWallHotMouldMm`	`number`	foundrylab_dmc: hot-mould thin-wall limit, mm (provisional, by alloy; the conventional and die-cast references are reported beside it) > 0
`params.needsHardenedNozzle`	`boolean`	fdm_x1c: this filament is abrasive (CF/GF filled) and needs a hardened nozzle — drives x1c_nozzle_material_compat
`params.nominalWall`	`number`	injection moulding: nominal wall, mm — drives the internal-radius limit (0.25 x nominalWall) > 0
`params.noseRadius`	`number`	turning: the finishing insert's NOSE radius, mm — the smallest internal corner a turning tool can leave in a shoulder (default 0.8) > 0
`params.nozzle`	`enum`	fdm_x1c (0.2/0.4/0.6/0.8) and fdm + printer (the printer record's fitted set): fitted nozzle, mm. Selects the line-width / layer-height row — every wall and text limit is a function of it. 0.4 is hardened steel (takes CF/GF filament); 0.2 is stainless and is not (default "0.4") one of "0.2", "0.25", "0.3", "0.4", "0.5", "0.6", "0.8", "1.0"
`params.objectSpacing`	`number`	fdm_x1c: centre-to-centre spacing of by-object neighbours, mm — one body does not carry the plate layout, so it is declared > 0
`params.outerWallLineWidth`	`number`	fdm_x1c: override the nozzle row's outer wall line width, mm (0.42 at the 0.4 nozzle) > 0
`params.overhangDeg`	`number`	lpbf / lpbf_printer: self-supporting overhang angle past vertical, deg — from the material row where a public figure exists (316L 55), else the shared 45; your own number wins > 0 · ≤ 90
`params.overhangFailDeg`	`number`	fdm_x1c: overhang REFUSAL angle past vertical, deg — from the filament row (PLA/PETG 55, ABS/ASA/PC 50) > 0
`params.overhangWarnDeg`	`number`	fdm_x1c: overhang WARN angle past vertical, deg — from the filament row (PLA/PETG 45, ABS/ASA/PC 40) > 0
`params.plateThickness`	`number`	lpbf_dmp_flex350: build-plate thickness, mm — subtracted from the 420 mm Z envelope (3D Systems publish Z including the plate; the plate itself is unpublished) ≥ 0
`params.pourTempC`	`number`	foundrylab_dmc: pour temperature, C; overrides the alloy typical value in foundrylab_alloy_window > 0
`params.printableArea`	`number[]`	fdm_x1c: plate size [x, y] mm, for the bed-placement arithmetic (default [256, 256]) exactly 2 items
`params.printer`	`string`	fdm / lpbf / binder_jet / ded / resin: a data/printers id or alias. process "fdm" + printer runs the registry-driven fdm_printer pack (fdm_x1c for the X1C); process "lpbf" + printer runs the registry-driven lpbf_printer pack (lpbf_dmp_flex350 for the DMP Flex 350); "ded" + a ded / waam / ebam printer runs the DED pack; resin: ops/resinRules.paramsForPrinter() turns it into tech + maxPartSize
`params.pullDirection`	`number[]`	foundrylab_dmc: split axis for depowder and draft (default: best of X, Y, Z). injection moulding: mould pull / ejection direction (default [0,0,1]) exactly 3 items
`params.reliefDepth`	`number`	oshcut_bend / scs_bend: required bend-relief notch depth away from the bend line, mm (default inside bend radius + materialThickness) > 0
`params.reliefWidth`	`number`	oshcut_bend / scs_bend: required bend-relief notch width along the bend line, mm (default one materialThickness) > 0
`params.sequentialPrinting`	`boolean`	fdm_x1c: by-object (sequential) printing — arms the extruder clearance envelope (90 mm to the lid, 68 mm radius)
`params.sequentialRadius`	`number`	fdm_x1c: extruder clearance radius for by-object printing, mm (default 68) > 0
`params.shellMm`	`number`	foundrylab_dmc: mould shell thickness for the envelope check, mm (provisional default 6, copper 8) > 0
`params.shrink`	`number[]`	binder_jet: linear sinter shrink X,Y,Z fractions; default from the material exactly 3 items
`params.shrinkPct`	`number`	foundrylab_dmc: REQUIRED linear shrink allowance for this job, percent. There is no default: Foundry Lab decide it case by case, and a call without it is refused (FOUNDRYLAB_SHRINK_REQUIRED) > 0 · < 10
`params.spindleAxis`	`number[]`	turning: the axis the part is turned about (default [0,0,1] — what `revolve` and every shaft_* op build about) exactly 3 items
`params.standardDrills`	`number[]`	scs_mill: stocked drill diameters, mm — holes off this list are flagged as un-tool-matched (a cost warning, never a block) ≥ 1 items · ≤ 64 items
`params.supportRegions`	`string[]`	fdm_x1c: face ids the caller accepts support on — exempt from x1c_overhang, the bridge rules and x1c_unsupported_island
`params.supportedWall`	`number`	resin: supported-wall floor, mm (sla 0.4, msla 0.5) — min_wall_thickness > 0
`params.tapMajorDiameters`	`number[]`	scs_mill: tap major diameters, mm — a tap-ready hole is modelled at major diameter and counts as tool-matched ≥ 1 items · ≤ 64 items
`params.tech`	`enum`	resin: "sla" (Formlabs Form 4/4L, Formlabs design-guide numbers) or "msla" (consumer masked-LCD: Elegoo Saturn/Mars, Anycubic Photon — Hubs SLA numbers). Default "sla" one of "sla", "msla"
`params.textFeatures`	`object[]`	fdm_x1c: [{ id, kind: "emboss"\|"engrave", strokeWidth, depth\|height, onFace: "top"\|"vertical", faceId }] — cad_engrave_text reports the stroke it cut as dfm.strokeWidth
`params.thicknessRange`	`number[]`	stocked material thickness range [min, max] in mm, checked against the part's smallest bounding-box dimension ≥ 1 items · ≤ 64 items
`params.toleranceTier`	`string`	fictiv_mill / fictiv_im: which published tolerance tier the quote is against ("iso2768m" = model with no drawing, "with_drawing" = +/-0.01 mm). Reported in pack.limits.tolerance; an inspection tolerance is not geometry, so no rule checks it
`params.toolAxis`	`number[]`	machining / sheet metal: tool (spindle or punch) axis (default [0,0,1]) exactly 3 items
`params.toolMatchTolerance`	`number`	scs_mill / fictiv_lathe: how close a feature must be to a stocked tool size to count as matched, mm (default 0.05) > 0
`params.trailingEdgeDihedralDeg`	`number`	investment_casting: the dihedral angle (through the material) below which two adjoining faces count as a knife-edge trailing-edge candidate, degrees (default 30) > 0 · ≤ 180
`params.trailingEdgeMinMm`	`number`	investment_casting: minimum as-cast trailing-edge thickness, mm — drives min_trailing_edge_thickness (default 0.6 mm) > 0
`params.unsupportedWall`	`number`	resin: unsupported-wall recommendation, mm (sla 0.6, msla 1.0) — resin_unsupported_wall > 0
`params.useAms`	`boolean`	fdm_x1c: declare AMS use without a slot map
`params.warpIndex`	`number`	fdm_x1c: shrinkage class of the filament, 1 (PLA) to 5 (PC) — the material term of the warping score ≥ 0
`params.wireDiameter`	`number`	ded (ded_wire): wire diameter, mm — selects the Meltio min-wall row (0.8 / 1.0 / 1.2; default 1.0) > 0
`printer` optional	`string`	A data/printers id or alias ("prusa-core-one", "x1c", "eos-m-290"). With pack fdm/lpbf/binder_jet runs that machine's registry pack; = params.printer. length ≥ 1
`process` optional	`array \| string`	run this process's DFM rule pack as well as the validity check. Omit for validity only (unchanged legacy behaviour). Name SEVERAL processes — ["scs_laser","scs_bend"] or "scs_laser+scs_bend" — when the part is made by a ROUTE: every pack is evaluated against the same body, each rule reports the BINDING limit (the most restrictive in the route) with the pack that publishes it in `rules[].binding`, every pack's own verdict in `rules[].sources`, and each violation the process(es) that flagged it at the worst of their severities. Severity does NOT escalate across packs: scs_bend's warning stays a warning even though scs_laser marks the same rule blocking at a looser number.
`rules` optional	`object`	per-rule overrides so a shop can retune the gate without forking the pack; an unknown rule code is refused rather than ignored
`rules.bend_radius`	`object`	—
`rules.bend_radius_available`	`object`	—
`rules.bend_relief`	`object`	—
`rules.binder_jet_depowder`	`object`	—
`rules.binder_jet_green_envelope`	`object`	—
`rules.binder_jet_min_pin`	`object`	—
`rules.binder_jet_min_slot`	`object`	—
`rules.binder_jet_sinter_bridge`	`object`	—
`rules.binder_jet_wall_for_size`	`object`	—
`rules.cold_spray_access`	`object`	—
`rules.cold_spray_line_of_sight`	`object`	—
`rules.cold_spray_round_build`	`object`	—
`rules.ded_hole_stock`	`object`	—
`rules.ded_overhang`	`object`	—
`rules.ded_overhang_tilt`	`object`	—
`rules.ded_substrate`	`object`	—
`rules.die_keepout_clear`	`object`	—
`rules.drainability`	`object`	—
`rules.ebm_down_skin_angle`	`object`	—
`rules.ebm_max_aspect_ratio`	`object`	—
`rules.ebm_max_unsupported_bridge`	`object`	—
`rules.ebm_min_gap`	`object`	—
`rules.ebm_min_pin`	`object`	—
`rules.ebm_overhang`	`object`	—
`rules.ebm_round_chamber`	`object`	—
`rules.ebm_sintered_cake_removal`	`object`	—
`rules.ebm_wall_printable`	`object`	—
`rules.fdm_exclusion_zones`	`object`	—
`rules.fdm_nozzle_temp`	`object`	—
`rules.fdm_round_bed`	`object`	—
`rules.flange_length`	`object`	—
`rules.flange_support_ratio`	`object`	—
`rules.foundrylab_alloy_window`	`object`	—
`rules.foundrylab_depowder_access`	`object`	—
`rules.foundrylab_draft`	`object`	—
`rules.foundrylab_hot_spots`	`object`	—
`rules.foundrylab_min_cored_hole`	`object`	—
`rules.foundrylab_min_wall`	`object`	—
`rules.foundrylab_mould_envelope`	`object`	—
`rules.foundrylab_shrink_allowance`	`object`	—
`rules.gauging_surface`	`object`	—
`rules.hole_to_bend`	`object`	—
`rules.lpbf_down_skin_angle`	`object`	—
`rules.lpbf_max_aspect_ratio`	`object`	—
`rules.lpbf_max_unsupported_bridge`	`object`	—
`rules.lpbf_min_gap`	`object`	—
`rules.lpbf_min_pin`	`object`	—
`rules.lpbf_overhang`	`object`	—
`rules.lpbf_recoater_collision`	`object`	—
`rules.lpbf_round_plate`	`object`	—
`rules.lpbf_trapped_powder`	`object`	—
`rules.lpbf_wall_printable`	`object`	—
`rules.material_needs_enclosure`	`object`	—
`rules.material_thickness`	`object`	—
`rules.max_bend_angle`	`object`	—
`rules.max_hole_depth_ratio`	`object`	—
`rules.max_material_removal`	`object`	—
`rules.max_overhang_angle`	`object`	—
`rules.max_pocket_depth_ratio`	`object`	—
`rules.max_rib_thickness_ratio`	`object`	—
`rules.max_section_ratio`	`object`	—
`rules.max_slenderness`	`object`	—
`rules.metal_fff_aspect`	`object`	—
`rules.metal_fff_green_envelope`	`object`	—
`rules.metal_fff_max_wall`	`object`	—
`rules.metal_fff_min_pin`	`object`	—
`rules.metal_fff_sinter_furnace`	`object`	—
`rules.min_bend_radius`	`object`	—
`rules.min_draft_angle`	`object`	—
`rules.min_fillet_radius`	`object`	—
`rules.min_hole_diameter`	`object`	—
`rules.min_internal_corner_radius`	`object`	—
`rules.min_section`	`object`	—
`rules.min_trailing_edge_thickness`	`object`	—
`rules.min_wall_thickness`	`object`	—
`rules.min_web_vs_sheet`	`object`	—
`rules.part_envelope`	`object`	—
`rules.resin_hollow_drain`	`object`	—
`rules.resin_min_feature`	`object`	—
`rules.resin_suction_cup`	`object`	—
`rules.resin_unsupported_island`	`object`	—
`rules.resin_unsupported_wall`	`object`	—
`rules.seam_gap`	`object`	—
`rules.sinter_cavity_drain`	`object`	—
`rules.sinter_green_envelope`	`object`	—
`rules.sinter_overhang_sag`	`object`	—
`rules.tall_on_bedslinger`	`object`	—
`rules.tool_matched_features`	`object`	—
`rules.tpu_on_bowden`	`object`	—
`rules.turning_axisymmetry`	`object`	—
`rules.turning_envelope`	`object`	—
`rules.x1c_ams_tpu`	`object`	—
`rules.x1c_bed_edge_chamfer`	`object`	—
`rules.x1c_bed_exclusion`	`object`	—
`rules.x1c_bridge_advisory`	`object`	—
`rules.x1c_bridge_span`	`object`	—
`rules.x1c_hole_compensation`	`object`	—
`rules.x1c_horizontal_hole_teardrop`	`object`	—
`rules.x1c_mating_clearance`	`object`	—
`rules.x1c_min_pin_diameter`	`object`	—
`rules.x1c_multicolour_cost`	`object`	—
`rules.x1c_nozzle_material_compat`	`object`	—
`rules.x1c_overhang`	`object`	—
`rules.x1c_pin_advisory`	`object`	—
`rules.x1c_recommended_wall`	`object`	—
`rules.x1c_sequential_clearance`	`object`	—
`rules.x1c_text_legibility`	`object`	—
`rules.x1c_unsupported_island`	`object`	—
`rules.x1c_warp_risk`	`object`	—
`rules.x1c_z_anisotropy`	`object`	—
`tier` optional	`enum`	default "full" one of "local", "full"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_moldability` write Mouldability: sizing, parting, gate, blends, cast scan feedback

Post-draft mouldability finishing.

Full description

Two independent modes, and a call may use either or both. Call cad_help({tool:"cad_moldability"}) for the rest.

Argument	Type	Meaning & bounds
`alloy` optional	`string`	al zn mg cu fe
`blendRatio` optional	`number`	Corner radius / wall. > 0
`boss` optional	`object`	Size a boss.
`boss.height`	`number`	Boss height, mm. > 0
`boss.wall`	`number`	Base wall, mm. > 0
`boss.coreDraft`	`number`	Core-pin draft, deg.
`boss.draft`	`number`	Per-side draft, deg.
`boss.holeDiameter`	`number`	Cored hole, mm (0 = solid).
`boss.minWall`	`number`	Top floor, mm. > 0
`castProcess` optional	`enum`	— one of "printed", "sand", "die"
`cavityPressureMPa` optional	`number`	Cavity pressure, MPa. > 0
`feedback` optional	`object`	—
`feedback.action`	`enum`	— one of "compare", "compensate", "learn", "recommend"
`feedback.defects`	`string[]`	—
`feedback.gain`	`number`	— ≥ 0.05 · ≤ 1.5
`feedback.maxMove`	`number`	— > 0
`feedback.out`	`string`	—
`feedback.output`	`enum`	— one of "mesh", "brep"
`feedback.part`	`string`	—
`feedback.scan`	`string`	STL/OBJ/PLY
`feedback.shrink`	`number`	—
`feedback.store`	`string`	—
`flowRatioLimit` optional	`number`	Max flow:wall ratio. > 0
`minDraft` optional	`number`	Minimum draft, DEGREES.
`minWall` optional	`number`	Thinnest wall, mm. > 0
`process` optional	`enum`	"casting": cast-mould review. one of "injection", "casting"
`pull` optional	`number[]`	Pull vector. exactly 3 items
`resin` optional	`string`	Resin key for flow ratio an…
`rib` optional	`object`	Size a rib.
`rib.height`	`number`	Rib height, mm. > 0
`rib.wall`	`number`	Base wall, mm. > 0
`rib.draft`	`number`	Per-side draft, deg.
`rib.minWall`	`number`	Tip floor, mm. > 0
`rib.ribRatio`	`number`	Max base / wall. > 0
`rib.sides`	`enum`	— one of "both", "one"
`solid` optional	`string`	Body handle.
`solidify` optional	`object`	action check\|simulate\|loop…
`wall` optional	`object`	Size a shelled wall.
`wall.height`	`number`	Wall height, mm. > 0
`wall.draft`	`number`	Per-side draft, deg.
`wall.minWall`	`number`	Floor, mm. Default 1. > 0
`wall.parting`	`boolean`	Parting splits the wall at…
`wall.wall`	`number`	Neutral-plane wall, mm. > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_design_review` write Automated design review packet

Run a complete design review of one part in a single call and emit one packet.

Full description

Call cad_help({tool:"cad_design_review"}) for the rest.

Argument	Type	Meaning & bounds
`analytic` optional	`object`	Expected analytic volume/ar…
`bodyIndex` optional	`integer`	Which solid of a multi-body… ≥ 0
`checks` optional	`enum[]`	Extra checks.
`complexity` optional	`object`	kind:"complexity" only…
`complexity.mount`	`number[]`	The point the stiffness pro… exactly 3 items
`complexity.process`	`enum`	How the part is made. one of "machining", "printing", "fabrication"
`dfmTier` optional	`enum`	ops/check.js tier for the D… one of "local", "full"
`document` optional	`string`	kind:"assembly"/"furniture"… length ≥ 1
`file` optional	`string`	Path to the STEP… length ≥ 1
`furniture` optional	`object`	kind:"furniture" only — t…
`furniture.edgeRadius`	`number`	The maker's edge radius in mm. > 0
`furniture.envelope`	`object`	Stated overall size in mm.
`furniture.partCount`	`object`	The spec sheet's part-count…
`furniture.seatHeight`	`number`	Intended sitting-surface he… > 0
`furniture.symmetric`	`boolean`	true: judge mirror symmetry…
`includeHtml` optional	`boolean`	Return the full HTML report…
`issueOffset` optional	`integer`	With maxIssues: skip this m… ≥ 0 · default `0`
`kind` optional	`enum`	What is being reviewed. one of "part", "assembly", "furniture", "complexity"
`label` optional	`string`	Title for the review, print… length ≤ 200
`material` optional	`string`	Recorded and printed only. length ≤ 120
`maxIssues` optional	`integer`	Cap the grouped… ≥ 1 · default `20`
`notes` optional	`string`	Free text printed under the… length ≤ 2000
`orientation` optional	`enum`	— one of "landscape", "portrait"
`outputDir` optional	`string`	Where to write the packet.
`packetId` optional	`string`	Override the generated pack… length ≤ 120
`partNumber` optional	`string`	Printed in the header and t… length ≤ 120
`persist` optional	`boolean`	Write the packet to disk…
`preparedFor` optional	`string`	Who the review is for — a… length ≤ 200
`projection` optional	`enum`	View arrangement: "third"… one of "first", "third"
`reviewer` optional	`string`	— length ≤ 120
`revision` optional	`string`	— length ≤ 60
`sheetSize` optional	`string`	Drawing sheet size for the…
`solid` optional	`string`	Review a body already built… length ≥ 1
`strict` optional	`boolean`	kind:"assembly"/"furniture"…
`thinWallThreshold` optional	`number`	Wall thickness below which… > 0
`titleBlockTemplate` optional	`string`	Title-block template key…
`views` optional	`enum[]`	Standard views to draw. ≤ 7 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_wind_tunnel` write Wind tunnel (CFD)

CFD on a solid: Cl/Cd/Cm around it, or (mode "internal") the flow through it.

Full description

Call cad_help({tool:"cad_wind_tunnel"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	A body handle returned by an earlier modeling-tool call (its "handle" value, or one entry of its "bodies"). Not a kernel op id, and not a "document" handle. length ≥ 1
`AoA` optional	`number`	angle in degrees, [-45, 45] ≥ -45 · ≤ 45
`blockageMax` optional	`number`	— > 0
`bodies` optional	`string[]`	a non-empty array of non-empty strings ≥ 1 items
`cellsAcross` optional	`integer`	a positive integer ≥ 1
`compressible` optional	`object`	the compressible regime's inputs (regime "compressible" only): mach, the freestream (altitude, or pressure + temperature), gamma, model, backend, wallTemperature, refArea / refLength / momentCenter, saveVtk
`compressible.mach`	`number`	freestream Mach number, 0.3-25 (compressible-mach-range outside) > 0
`compressible.altitude`	`number`	geometric altitude, m, U.S. Standard Atmosphere 1976 (-610 m to ~86 km; default 0); not with pressure/temperature
`compressible.backend`	`enum`	a document op runs on the CPU; "gpu" is refused (compressible-gpu-unavailable) one of "auto", "gpu", "cpu"
`compressible.gamma`	`number`	ratio of specific heats, 1.05-5/3 (default 1.4) > 0
`compressible.model`	`enum`	"euler" (default, slip wall) \| "laminar" (no-slip, resolved wall) \| "SA" (Spalart-Allmaras + equilibrium wall model); "wallModel" alone is refused (compressible-model-unsupported) one of "euler", "laminar", "wallModel", "SA"
`compressible.momentCenter`	`number[]`	moment reference point, model units (default: the bounding-box centre) exactly 3 items
`compressible.pressure`	`number`	freestream static pressure, Pa (with temperature, instead of altitude) > 0
`compressible.refArea`	`number`	reference area, model units^2 (default: the frontal shadow area) > 0
`compressible.refLength`	`number`	reference length, model units (default: the largest bounding-box extent) > 0
`compressible.saveVtk`	`string`	path of the volume VTK (relative to baseDir); <name>.surface.vtk is written beside it length ≥ 1
`compressible.temperature`	`number`	freestream static temperature, K (with pressure, instead of altitude) > 0
`compressible.wallTemperature`	`number`	isothermal wall, K (viscous models only; default adiabatic) > 0
`conductivity` optional	`number`	— > 0
`density` optional	`number`	— > 0
`direction` optional	`number[]`	[x, y, z] in millimetres exactly 3 items
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field, or the literal "new" to start a SECOND, independent, empty document (for a separate part in the same session — each document builds and exports independently, so two parts in two documents export as two separate STEP files). Omit to use this session's default document (created automatically on first use). length ≥ 1
`dryRun` optional	`boolean`	—
`duration` optional	`number`	transient run length in SECONDS of simulated time (exactly one of duration / revolutions) > 0
`eddyViscosityCap` optional	`number \| string`	eddy-viscosity ceiling: "auto" = min(1.0, 0.01UL) (the CADSF-536 default), "legacy" = the flat 1.0 m^2/s ceiling that pre-dates it, or an explicit positive number of m^2/s
`emitField` optional	`boolean`	—
`emitVtk` optional	`boolean`	—
`gridRes` optional	`integer \| string`	named preset or an explicit integer grid resolution (>= 8 cells across the short axis)
`groundVelocity` optional	`number`	—
`heat` optional	`object[]`	internal mode ports: inlets [{faces, velocity\|massFlow, profile?, temperature?}], outlets [{faces, pressure?}], heat [{faces, power\|temperature}]; every other face is a no-slip adiabatic wall ≥ 1 items
`inlets` optional	`object[]`	internal mode ports: inlets [{faces, velocity\|massFlow, profile?, temperature?}], outlets [{faces, pressure?}], heat [{faces, power\|temperature}]; every other face is a no-slip adiabatic wall ≥ 1 items
`iterations` optional	`integer`	a positive integer ≥ 1
`jobMode` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`kinematicViscosity` optional	`number`	— > 0
`minCellsAcrossThin` optional	`integer`	cells across the thinnest body axis; prefer 8-12 ≥ 4
`mode` optional	`enum`	"external" (default): Cl/Cd/Cm around the body. "internal": flow THROUGH it — the body is the fluid volume. "transient" (CADSF-102610): rotating bodies in a time-accurate run, with rotatingZones and duration \| revolutions; dryRun:true returns the resolved zones and the cell estimate; without dryRun it is solved on the CPU reference within its limits, else refused rotating-transient-needs-gpu carrying the plan one of "external", "internal", "transient"
`movingWalls` optional	`object[]`	per-surface moving-wall boundary conditions (rotating wheels, translating belts) ≥ 1 items
`outlets` optional	`object[]`	internal mode ports: inlets [{faces, velocity\|massFlow, profile?, temperature?}], outlets [{faces, pressure?}], heat [{faces, power\|temperature}]; every other face is a no-slip adiabatic wall ≥ 1 items
`padding` optional	`object`	wind-tunnel domain sizing overrides, body-span multiples >= 0
`padding.bottom`	`number`	bottom domain padding, body-span multiples ≥ 0
`padding.inlet`	`number`	inlet domain padding, body-span multiples ≥ 0
`padding.left`	`number`	left domain padding, body-span multiples ≥ 0
`padding.outlet`	`number`	outlet domain padding, body-span multiples ≥ 0
`padding.right`	`number`	right domain padding, body-span multiples ≥ 0
`padding.top`	`number`	top domain padding, body-span multiples ≥ 0
`placementSensitivity` optional	`boolean`	—
`preset` optional	`enum`	seeds a full CFD config; explicit fields override it one of "external-aero", "automotive-ground", "quick-look"
`projectionSweeps` optional	`integer`	a positive integer ≥ 1
`refinement` optional	`object`	—
`refinement.zones`	`object[]`	1-32 zones; overlapping ones merge to a union box ≥ 1 items · ≤ 32 items
`refinementRatio` optional	`number`	— > 0
`regime` optional	`enum`	"incompressible" (default): the MAC-grid solve. "compressible": the mesh-free compressible solver (its inputs in "compressible": mach, altitude or pressure + temperature, gamma, model, ...); refusals carry compressible-* reasonCodes one of "incompressible", "compressible"
`residualTarget` optional	`number`	normalized L-infinity velocity-change convergence target, (0, 1) > 0 · ≤ 1
`revolutions` optional	`number`	transient run length in TURNS of the fastest rotating zone (needs a zone; exactly one of duration / revolutions) > 0
`reynolds` optional	`number`	— > 0
`rotatingZones` optional	`object[]`	rotating zones (<= 16): mode "internal" maps them onto the steady rotating-frame solve (omega, axis, centre -> origin, radius -> rMax, +-halfHeight -> zMin/zMax; no inlets/outlets = a closed rotating cavity); mode "transient" resolves them into a dry-run plan; external mode refuses a non-empty list (rotating-zones-need-transient) ≤ 16 items
`sampleEvery` optional	`number`	transient sampling interval in the SAME unit as the run length given: seconds with duration, revolutions with revolutions > 0
`saveStl` optional	`string`	— length ≥ 1
`scaleInvariant` optional	`boolean`	—
`sideslip` optional	`number`	angle in degrees, [-45, 45] ≥ -45 · ≤ 45
`sizing` optional	`object`	sizing field (CADSF-1564): "refine to h inside this region", MODEL frame, millimetres. Mutually exclusive with "refinement", which states the same zones in SI metres in the flow frame.
`sizing.regions`	`object[]`	up to 32 regions, one nested block each; overlapping regions merge (union box, finer ratio); over 800,000 fine cells across blocks is refused (sizing-cell-budget) ≥ 1 items · ≤ 32 items
`sizing.angularCapDeg`	`number`	— > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	— ≥ 1
`sizing.featureEdges`	`boolean`	—
`sizing.growthRatio`	`number`	— ≥ 1 · ≤ 2
`sizing.hMax`	`number`	— > 0
`sizing.hMin`	`number`	— > 0
`sizing.maxDepth`	`integer`	— ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	— > 0
`sizing.proximity`	`boolean`	—
`skinFriction` optional	`boolean \| string`	viscous wall-stress term in the force integration: false (default — the pressure-only form-drag integral), true (= "wallFunction"), or a named model. OPT-IN deliberately: CADSF-536 measured it worse on every validation case as a default
`specificHeat` optional	`number`	— > 0
`stations` optional	`integer`	a positive integer ≥ 1
`suppressed` optional	`boolean`	true = this feature is DELIBERATELY not built (the feature tree's eye toggle). It contributes no geometry and publishes no id, so an op that references it is skipped too (reported as "suppressedByFailure") while every feature independent of it still builds; the result carries "partial": true and a per-feature state. Default false. Un-suppressing rebuilds from that feature.
`turbulence` optional	`enum`	plain "k-omega" (Wilcox) is NOT implemented and is rejected one of "k-epsilon", "k-omega-sst", "laminar", "none"
`turbulenceIntensity` optional	`number`	turbulence intensity, (0, 1) > 0 · ≤ 1
`turbulenceLengthScale` optional	`number`	— > 0
`units` optional	`enum`	units the SOLID is modelled in — normalized to SI metres at the CFD boundary one of "mm", "cm", "m", "in"
`velocity` optional	`number`	inlet velocity, m/s (SI) > 0 · ≤ 100
`wallPressureSampling` optional	`enum`	how the per-triangle force integration reads the pressure field: "nearest" = the floor-to-cell probe, "trilinear" = interpolated over the 8 surrounding fluid cells (the CADSF-536 default) one of "nearest", "trilinear"
`wallType` optional	`enum`	— one of "slip", "noSlip", "movingGround"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_verify` read Verify a part (render, diff, measure, heal)

Verify a built part before saving it: one report with validity (watertight, closed manifold, orientation, B-rep check, heal probe), topology (Betti numbers, holes, through holes), a spec check (named dimensions with tolerances, measured on the body, pass/fail + delta), an engineering-drawing check… Call cad_help({to…

Full description

ol:"cad_verify"}) for the rest.

Argument	Type	Meaning & bounds
`document` optional	`string`	Document handle (default: active).
`drawing` optional	`object`	A PNG drawing sheet to diff against.
`drawing.knownDimension`	`object`	Sets the sheet scale: the extent of `view` alon…
`drawing.path`	`string`	PNG file path.
`drawing.png`	`string`	Base64 PNG.
`drawing.projection`	`enum`	auto (default) detects it. one of "auto", "first", "third"
`drawing.views`	`object`	Optional explicit view boxes in sheet px: {"fro…
`export` optional	`object`	Check the save path.
`export.format`	`enum`	— one of "fcstd"
`export.freecad`	`boolean`	false skips the FreeCAD recompute.
`gate` optional	`object`	—
`heal` optional	`enum`	probe (default): when the body leaks, run the h… one of "probe", "off"
`images` optional	`integer`	PNGs returned inline… ≥ 0 · ≤ 12
`iouPass` optional	`number`	Min per-view IoU (default 0.95). ≥ 0 · ≤ 1
`label` optional	`string`	File name stem (default "part").
`of` optional	`string`	Body handle or op id (default: all solids).
`outDir` optional	`string`	Output folder (default verify/<label>).
`qa` optional	`object`	Also run the landed detector registry on this b…
`reference` optional	`object`	—
`reference.path`	`string`	.step/.stp, or .FCStd (needs FreeCAD).
`spec` optional	`array \| string`	Named dimensions: a list of items, or text line…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_build_orientation` read Build orientation (FDM and metal LPBF)

WHICH WAY UP to print a part, ranked and explained.

Full description

Candidates are the six axis-aligned directions, every planar face laid on the bed, and your hint; each is scored on support area, height, footprint, bed contact, cosmetic faces up and layer-bond anisotropy, using the fdm_x1c pack's own measurements. Call cad_help({tool:"cad_build_orientation"}) for the rest.

Argument	Type	Meaning & bounds
`solid` required	`string`	Body handle in this session… length ≥ 1
`allowCosmeticDown` optional	`boolean`	Let a cosmetic face go on t…
`autoCosmetic` optional	`boolean`	false: only the declared co…
`cosmeticFaces` optional	`string[]`	Face ids that must finish w…
`hint` optional	`number[]`	An extra build direction to… exactly 3 items
`loadAxis` optional	`number[]`	Direction the part is loade… exactly 3 items
`material` optional	`enum`	lpbf_dmp_flex350 alloy. one of "Ti64", "IN718", "316L"
`maxCandidates` optional	`integer`	Cap on candidates scored. ≥ 6 · ≤ 200
`maxOverhangFaces` optional	`integer`	Cap on heat-map rows per ca… ≥ 1 · ≤ 500
`pack` optional	`enum`	Rule pack whose numbers sco… one of "fdm_x1c", "lpbf_dmp_flex350"
`params` optional	`object`	fdm_x1c pack params the swe…
`params.bedExcludeArea`	`object`	The refused plate rectangle…
`params.material`	`string`	Filament; tightens the over…
`params.maxPartSize`	`number[]`	Build volume, mm. exactly 3 items
`params.nozzle`	`string`	Fitted nozzle, mm.
`params.printableArea`	`number[]`	Plate size, mm. exactly 2 items
`params.supportRegions`	`string[]`	Face ids you accept support…
`recoaterAxis` optional	`number[]`	lpbf: recoater travel direc… exactly 3 items
`supportAnalysis` optional	`boolean`	Score the support term from…
`threshold` optional	`number`	fdm_x1c: overhang angle pas… > 0 · < 90
`topN` optional	`integer`	lpbf: candidates returned… ≥ 1 · ≤ 200
`translate` optional	`enum`	bed (default) drops the par… one of "bed", "none"
`weights` optional	`object`	Per-term score weights; neg…
`weights.anisotropy`	`number`	fdm_x1c anisotropy weight.
`weights.buildHeight`	`number`	lpbf buildHeight weight.
`weights.contact`	`number`	fdm_x1c contact weight.
`weights.cosmetic`	`number`	fdm_x1c cosmetic weight.
`weights.distortionRisk`	`number`	lpbf distortionRisk weight.
`weights.downSkinArea`	`number`	lpbf downSkinArea weight.
`weights.footprint`	`number`	fdm_x1c footprint weight.
`weights.height`	`number`	fdm_x1c height weight.
`weights.keepOut`	`number`	lpbf keepOut weight.
`weights.partToPart`	`number`	lpbf partToPart weight.
`weights.recoaterRisk`	`number`	lpbf recoaterRisk weight.
`weights.support`	`number`	fdm_x1c support weight.
`weights.supportVolume`	`number`	lpbf supportVolume weight.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Returns no structured fields.

Exactly one of these argument shapes: pack + process + solidId + material + threshold + weights + candidates + best + stats + units — or — pack + solidId + threshold + weights + candidates + best + stats + units — or — error.

`cad_fea_case` write Write an FEA case (STL + BC patches + case.json)

Export a built body as a stress-analysis case: body.stl, one patch_<n>.stl per boundary condition and case.json (docs/FEA_CASE.md).

Full description

Needs no solver. BCs are face-selected by "faceId" from cad_body_topology; at least one fixed/sliding BC is required. Call cad_help({tool:"cad_fea_case"}) for the rest.

Argument	Type	Meaning & bounds
`boundaryConditions` required	`object[]`	At least one, and at least one of kind fixed/sliding — except a free-free modal case (solve.physics "modal" + solve.freeFree true), which is the one case that may pass []. ≥ 0 items
`caseDir` required	`string`	Directory to write the case into (created; relative paths resolve under the configured output directory). A previous results.json there is removed.
`bodyLoads` optional	`object[]`	—
`exportDeck` optional	`enum[]`	"inp": case.inp, the CalculiX deck (Abaqus keyword dialect). "bdf": case.bdf, the Nastran/MYSTRAN deck (SOL 101 static, 103 modal, 105 buckling; single body, isotropic, no temperature field). Both are written on ONE mesh. Returned as decks[] {format, deckPath, howToRun, mesh}; a deck the case cannot have is {ok:false, error} by name and the other is still written. Nothing is solved.
`lattice` optional	`object`	Fast lattice FEA: {mode:"homogenised"\|"explicit", cell (gyroid\|schwarz-p\|schwarz-d\|cubic\|bcc\|fcc\|octet\|kelvin\|diamond\|fdm-<infill>), rho (number \| {linear:{axis, from:[mm, rho], to:[mm, rho]}} \| {points:[[x,y,z,rho]]}), cellSizeMm, skinMm?}. "homogenised": elements deeper than skinMm get RVE (anisotropic) lattice stiffness; the skin stays solid. "explicit": the body is the meshed lattice.
`material` optional	`string \| object`	A preset (steel, aisi-1018, stainless-304, aluminum, al-6061-t6, titanium, abs, nylon) or SI values; an object may name a preset and override fields. Default "steel". FDM presets (pla-fdm, petg-fdm, abs-fdm, asa-fdm, pa-cf-fdm) are orthotropic, XY vs Z, sourced (docs/FEA_CASE.md); with one an object takes only {preset, name, buildDirection}. Fatigue fields are read only by blade qualification.
`provenance` optional	`object`	Free-form; copied into case.json (the demo loop records the fillet radius per iteration here).
`rotor` optional	`object`	Rotor block, same shape as cad_modal.rotor — axis {point, direction}, speedRpm, bladeCount, engineOrders, dampingRatio, excitation (docs/FEA_CASE.md § Rotor block). Requires solve.physics "modal"; a static case with a rotor is refused rotor_requires_modal.
`solid` optional	`string`	A body handle already built in the session (an op id, or "<id>#<n>"). One of solid or solids is required.
`solids` optional	`object[]`	MULTI-BODY case (case.json v2): one entry per part, each with its own material. The parts are solved as one scenario at the positions they are built at — the solver bonds domains that share a surface, so a flattened assembly analyses as an assembly. Use instead of "solid". ≥ 1 items
`solve` optional	`object`	—
`solve.basisOrder`	`enum`	Meshfree-adapter basis order (CalculiX ignores it). 2 resolves bending stress; 1 under-reads a fillet peak ~2x. one of 1, 2 · default `2`
`solve.bucklingModes`	`integer`	buckling only: load factors to extract; 5 if omitted. ≥ 1 · ≤ 50
`solve.freeFree`	`boolean`	modal: solve with NO restraint (free blade, panel); else a BC-less modal case is refused "unrestrained". Modes 1-6 are then rigid-body ~0 Hz.
`solve.frequencyRange`	`number[]`	modal: [lowHz, highHz] band; omit for the lowest modeCount. exactly 2 items
`solve.modeCount`	`integer`	modal only: how many eigenpairs to extract, lowest first; 10 if omitted. Refused on a static case. ≥ 1 · ≤ 200
`solve.nonlinear`	`object`	Nonlinear static, CalculiX only: geometric (NLGEOM, default true), material elastic\|plastic (plastic needs material.plasticCurve/tangentModulusPa; steel, al-6061-t6, abs, nylon carry cited curves), steps (10), maxIncrements (100), unload (residual state). Per-increment reaction + plastic strain out; a run short of full load is refused not_converged with lastConvergedLoadFraction.
`solve.normalization`	`enum`	modal only: mode-shape scaling, "mass" (phi^T M phi = 1; default if omitted) or "max" (unit peak). one of "mass", "max"
`solve.physics`	`enum`	"linear-elastic"; "modal" (frequencies, needs densityKgM3, loads ignored); "buckling" (case loads as reference: load factors, critical load, verdict vs requiredFactor; C3D10; refused no_compression/load_required); "nonlinear-static" (set by solve.nonlinear). one of "linear-elastic", "modal", "buckling", "nonlinear-static" · default `"linear-elastic"`
`solve.requiredFactor`	`number`	buckling only: factor the lowest mode must reach to pass; 3 if omitted. > 0
`solve.resolution`	`integer`	Target cell count: CalculiX sizes its tets from it (a meshfree adapter reads it as its resolution). ≥ 100 · ≤ 2000000 · default `20000`
`solve.sizing`	`object`	Volume-mesh sizing: hMax / hMin (mm), maxTets (tet budget — the field is coarsened until the predicted count fits; refuses sizing_max_tets_unreachable).
`temperatureField` optional	`string \| object \| array`	Linear-static thermal load, prescribed nodal T (no conduction): an id (uniform\|linear\|radial_axial), {expression, params?, referenceC?, alphaPerC?}, or per-node degC ({nodalC} or a bare array). alphaPerC (1/degC) is required, here or from material. docs/FEA_CASE.md "Thermal load".
`tessellation` optional	`object`	—
`tessellation.maxTriangles`	`integer`	— ≥ 12
`tessellation.tolerance`	`number`	Chord tolerance (mm) for body.stl; default is the kernel's. > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_fea_run` write Run an FEA case and summarise the result

Solve a case written by cad_fea_case and return results.json (docs/FEA_CASE.md): max von Mises stress and where it is, max displacement, safety factor against the material yield, cell count, wall time — plus a one-line "summary" to quote.

Full description

Call cad_help({tool:"cad_fea_run"}) for the rest.

Argument	Type	Meaning & bounds
`caseDir` required	`string`	The caseDir cad_fea_case returned.
`deckOnly` optional	`boolean`	Write the CalculiX deck (case.inp, with this call's resolution / elementType / meshQuality) and STOP: deckPath + howToRun, no solve — for a machine with no solver or a run queued elsewhere. Needs no solver.
`elementType` optional	`enum`	CalculiX only: force quadratic (C3D10) or linear (C3D4) tets for THIS run. Omit — the default — to let the case decide: solve.elementOrder from case.json wins, and 2 (C3D10) if it says nothing. one of "C3D10", "C3D4"
`lattice` optional	`enum`	Override case.json lattice.mode for this run: "homogenised" (RVE stiffness in the lattice region) or "explicit" (solve the body as meshed). one of "homogenised", "explicit"
`manifest` optional	`boolean`	Attach result.manifest: the reproducible run manifest (tools/cert/manifest.js, ADR-24) — sha256 of case.json, the deck and results.json, the solver binary sha256 + version, kernel and node version, options. CalculiX only; a manifest that cannot be built (no ccx identity) comes back as {error} and never fails the run.
`meshQuality` optional	`boolean \| object`	CalculiX mesh-quality passes: ON by default (CADSF-1732), omit or true = deck default (featureDeg 30); false = opt out, raw mesh (qualityPasses false/false, slivers likely); object {featureDeg, improveSurface, improveQuality, improveOpts} tunes. results.mesh.qualityPasses / .quality say what ran and bought.
`refinementStudy` optional	`object`	—
`refinementStudy.quantities`	`object[]`	— ≥ 1 items
`refinementStudy.levels`	`integer`	— ≥ 3 · ≤ 5
`refinementStudy.ratio`	`number`	— ≥ 1.3
`resolution` optional	`integer`	Override case.json solve.resolution for this run. ≥ 100 · ≤ 2000000
`solver` optional	`string`	"auto" (default): every registered solver adapter in order, then CalculiX. "calculix": ccx only. An installed edition may register further names (cad_server_info lists them); naming one this deployment does not have is refused, never silently substituted. default `"auto"`
`targetSafetyFactor` optional	`number`	Your required safety factor on yield. Omit to judge against yield itself (fail < 1, marginal < 1.5). With it: fail < target, marginal < 1.2 x target. > 0
`timeoutSec` optional	`integer`	— ≥ 10 · ≤ 3600 · default `600`
`writeField` optional	`boolean`	Adapters that support it: also write results.vtu (the full field) next to results.json. CalculiX ignores it (it always leaves <job>.frd). The answer's verdict.viewer points at the field file on a fail/marginal result, else null + viewerReason.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_modal` write Natural frequencies and mode shapes (modal analysis)

Natural frequencies (Hz) and mode shapes of a body already built in the session — the whole modal loop in one call.

Full description

It writes a modal FEA case, solves it with CalculiX *FREQUENCY or MYSTRAN SOL 103, and returns the modes lowest-first plus "frequencyTable", a small markdown table to quote. Call cad_help({tool:"cad_modal"}) for the rest.

Argument	Type	Meaning & bounds
`body` required	`string`	A body handle already built in the session (an op id, or "<id>#<n>").
`material` required	`string \| object`	Required — an eigenvalue problem has no frequency without mass. A preset (steel, aisi-1018, stainless-304, aluminum, al-6061-t6, titanium, abs, nylon, pla-fdm, petg-fdm, abs-fdm, asa-fdm, pa-cf-fdm) or SI values {youngsModulusPa, poissonRatio, densityKgM3, name?}; an object may name a preset and override fields. densityKgM3 > 0 is mandatory (`density_required` otherwise).
`caseDir` optional	`string`	Directory to write the case into (created; a relative path resolves under the configured output directory). Defaults to "modal_<body>".
`deckOnly` optional	`boolean`	Write the case and the solver deck and STOP — for handing the run to a workstation or a queue. Returns deckPath + howToRun instead of modes. default `false`
`elementOrder` optional	`enum`	Tet order: 2 = C3D10 / 10-node CTETRA (the default — a linear tet reads a frequency 20-100 % HIGH, CADSF-1284/1289), 1 = C3D4 for a quick coarse pass. one of 1, 2 · default `2`
`fixedFaces` optional	`string[]`	"faceId" values from cad_body_topology, clamped in all dofs — the bolted/welded/clamped face. One of fixedFaces/slidingFaces is required unless freeFree is true. ≥ 1 items
`freeFree` optional	`boolean`	Solve UNRESTRAINED (a free blade, a satellite panel). Must be explicit: without it an unrestrained case is refused as "unrestrained". The first six modes are then rigid-body at ~0 Hz.
`frequencyRange` optional	`number[]`	[lowHz, highHz] band to search; omit for "the lowest modeCount modes". exactly 2 items
`modeCount` optional	`integer`	How many eigenpairs to extract, lowest first. ≥ 1 · ≤ 200 · default `10`
`normalization` optional	`enum`	Mode-shape scaling: "mass" (phi^T M phi = 1, the usual) or "max" (unit largest component). one of "mass", "max" · default `"mass"`
`provenance` optional	`object`	Free-form; copied into case.json and echoed back, so an iteration is self-describing.
`resolution` optional	`integer`	Target cell count for the volume mesh (case.json solve.resolution); default 20000. ≥ 100 · ≤ 2000000
`rotor` optional	`object`	Spinning-structure definition for blade qualification (docs/FEA_CASE.md § Rotor block). Needs solve.physics "modal" (else rotor_requires_modal).
`rotor.axis`	`object`	The rotation axis: a point on it (mm) and its direction (normalised for you; a zero direction is rotor_invalid).
`rotor.bladeCount`	`integer`	Blades on the disk, N. sectorAngleDeg = 360/N is derived from it. ≥ 1
`rotor.speedRpm`	`number`	Operating speed (rpm). omegaRadS and the ccx CENTRIF magnitude (omega^2) are derived from it. > 0
`rotor.cyclic`	`object`	Cyclic-symmetry sector: the face ids of its two cut faces.
`rotor.dampingRatio`	`number \| object`	Modal damping ratio zeta (not a %, not a Q). Default 0.002. Or {value, unit:"-", status:"ASSUMED", basis, range:{low,high}}. default `0.002`
`rotor.engineOrders`	`integer[]`	Excitation engine orders (kicks per revolution). Default [1, 2, V, 2V] from vaneCount; with no vaneCount there is no default (rotor_invalid) - a blade is kicked at the vane count, not its own bladeCount.
`rotor.engineOrdersReason`	`string`	Why a stated engineOrders omits the vane passing order V or its harmonic 2V. Blade qualification refuses such a list without it (engine_orders_incomplete) and prints it on the report headline. length ≥ 1
`rotor.excitation`	`object`	Optional forcing for the forced-response run (CADSF-1294). Carried through the contract as given.
`rotor.sectorAngleDeg`	`number`	Derived (360/bladeCount). Pass it only to assert it — an inconsistent value is rotor_invalid. > 0
`rotor.speedRangeRpm`	`number[]`	Campbell sweep [loRpm, hiRpm]; must contain speedRpm. Default [0, speedRpm]. exactly 2 items
`rotor.speedSteps`	`integer`	How many speeds in the sweep, inclusive of both ends — one prestressed modal solve each. ≥ 2 · ≤ 200 · default `16`
`rotor.vaneCount`	`object`	Upstream vane count WITH its provenance (docs/FEA_CASE.md): {value, unit:"vanes", status, why \| citation \| basis+range}. A bare integer is refused. Blade qualification requires it.
`slidingFaces` optional	`string[]`	Faces restrained along their own normal only — a seated flange free to slide in-plane. ≥ 1 items
`solver` optional	`enum`	"auto" = CalculiX if ccx is installed, else MYSTRAN, else write the deck and stop. one of "auto", "calculix", "mystran" · default `"auto"`
`targetHz` optional	`number`	Minimum first natural frequency you need (Hz), e.g. a drive or excitation frequency to stay above. Adds a pass / marginal / fail verdict (marginal = within 20 % above it). > 0
`tessellation` optional	`object`	—
`tessellation.maxTriangles`	`integer`	— ≥ 12
`tessellation.tolerance`	`number`	Chord tolerance (mm) for body.stl; default is the kernel's. > 0
`timeoutSec` optional	`integer`	— ≥ 10 · ≤ 3600 · default `600`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_topopt` write Topology optimisation (lightest shape that carries the loads)

Topology-optimise a body: the stiffest shape using volumeFraction of it, for several load cases at once.

Full description

keepIn faces stay solid; supports and loads take cad_body_topology face ids as in cad_fea_case (bearing = pin in a bore, moment = torque). mm, N. Writes <outDir>/topopt.stl + topopt.json. Next: cad_mesh_to_brep, then cad_fea_case/cad_fea_run. Minutes on a fine grid; streams progress.

Argument	Type	Meaning & bounds
`loadCases` required	`object[]`	— ≥ 1 items
`outDir` required	`string`	output directory (created)
`solid` required	`string`	design-space body handle
`supports` required	`object[]`	— ≥ 1 items
`crisp` optional	`boolean`	crisp 0/1 result default `true`
`iterations` optional	`integer`	— ≥ 1 · ≤ 1000 · default `120`
`keepIn` optional	`object[]`	—
`keepOut` optional	`object[]`	—
`material` optional	`string \| object`	feaCase preset or {youngsModulusPa, ...}
`minMemberMm` optional	`number`	min member radius > 0
`symmetry` optional	`object`	—
`symmetry.axis`	`enum`	— one of "x", "y", "z"
`symmetry.at`	`number`	mirror plane, mm
`targetVoxels` optional	`integer`	grid size if no voxelMm ≥ 1000 · ≤ 2000000 · default `40000`
`volumeFraction` optional	`number`	share of the body to keep > 0 · ≤ 1 · default `0.25`
`voxelMm` optional	`number`	grid pitch > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_combustion` read

Combustion chemistry (Cantera add-on).

Full description

Modes, args: cad_help.

Argument	Type	Meaning & bounds
`mode` required	`enum`	equilibrium: adiabatic flame T (HP) + species; flame_speed: 1-D premixed laminar S_L; ignition_delay: const-p reactor, max dT/dt; reactor_network: spec.zones PSR/PFR chain -> outlet T, NOx/CO/UHC, combustion efficiency, spec.blowout one of "equilibrium", "flame_speed", "ignition_delay", "reactor_network"
`T` optional	`number`	unburnt mixture / air temperature, K > 0 · ≤ 5000 · default `300`
`fuel` optional	`string`	CH4 \| C3H8 (GRI-Mech 3.0) \| JetA_surrogate (n-dodecane, Wang et al. Fuel 136 (2014) 25), or any species of spec.mechanism default `"CH4"`
`p` optional	`number`	pressure, Pa > 0 · ≤ 100000000 · default `101325`
`phi` optional	`number \| array`	equivalence ratio, one value or a sweep (reactor_network: the overall phi, first value) > 0 · ≤ 10 · ≥ 1 items · ≤ 40 items · default `1`
`spec` optional	`object`	everything else (all optional)
`spec.blowout`	`boolean`	reactor_network: also search the first PSR's blowout residence time
`spec.fuelMassFlowKgS`	`number`	reactor_network fuel flow, default 0.01 kg/s > 0
`spec.fuelSpecies`	`string`	— length ≥ 1
`spec.fuelT`	`number`	reactor_network fuel temperature K, default T > 0
`spec.jobMode`	`boolean`	run as an async job (cad_job_status / cad_job_result)
`spec.mechanism`	`string`	path to a Cantera YAML mechanism YOU supply - needed for a custom fuel, and for a JetA_surrogate flame_speed (the bundled n-dodecane mechanism has no transport data). Never downloaded. length ≥ 1
`spec.oxidizer`	`string`	composition, default air O2:1, N2:3.76 length ≥ 1
`spec.phase`	`string`	phase name inside the mechanism YAML length ≥ 1
`spec.tEndS`	`number`	ignition_delay window, default 0.1 s > 0 · ≤ 100
`spec.timeoutSec`	`integer`	worker wall clock, default 600 ≥ 1 · ≤ 86400
`spec.zones`	`object[]`	reactor_network chain in flow order; airFraction = share of the total air added at that zone (all sum to 1, the first > 0) ≥ 1 items · ≤ 32 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_turbomachine` write

Turbomachinery from a duty: meanline, curves/map, checks, B-rep assembly.

Full description

cad_help topic "turbomachine".

Argument	Type	Meaning & bounds
`duty` required	`object`	pump: flowM3h\|flowLs\|Q\|flowKgS + headM\|dpBar\|outletBar(+inletBar), npshA\|inletBar, stages; compressor: m, PR\|outletBar\|boostBar, inletC\|T01, inletBar\|p01; turbopump: m, outletBar, inletBar
`kind` required	`enum`	— one of "pump", "inducer", "compressor", "turbine", "turbocharger", "turbopump"
`fluid` optional	`any`	liquid name (water, seawater, LOX, RP-1, LCH4, LH2, light-oil), {rho, pVap}; air for a compressor. Default water / air / LOX
`options` optional	`object`	build:false (meanline only), checks:false, sweep:{param, values}, volutes, shroud, inducer, u2Max, stage, map, casing, rotor, meanline, name
`rpm` optional	`number`	shaft speed; omitted: chosen (motor speed for a pump, inducer Mach limit for a compressor, suction specific speed for a turbopump) > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_couple` read

Couple a fast model with solver calibrators (outer loop, gates).

Full description

Args: cad_help.

Argument	Type	Meaning & bounds
`action` required	`enum`	plan: validate + describe; run: execute the loop; replay: re-run a record with no solver; status: an async run (jobId) one of "plan", "run", "replay", "status"
`jobId` optional	`string`	status: the jobId run returned length ≥ 1
`jobMode` optional	`boolean`	run: as an async job (poll status / cad_job_result)
`record` optional	`object \| string`	replay: the coupling.run.v1 record a run returned, or a path to a saved one length ≥ 1
`spec` optional	`object \| string`	coupling spec (schema coupling.spec.v1: factors, model, calibrators, gates, loop, overrides), or a path to one; relative calibrator files resolve against its folder length ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_pcb` read PCB analysis, BOM and revision impact diff

Analyse a PCB layout (.kicad_pcb, Gerber X2 folder, IPC-2581 .xml) without building solids.

Full description

action analyze: impedance, dc, ampacity, thermal, cert, returnPath. bom: the parts list. diff: two revisions (files or git refs) -> impactDiff v1. Every result carries an assumptions ledger; missing inputs are refused by name. Call cad_help({tool:"cad_pcb"}) for the rest.

Arguments common to every format

Argument	Type	Meaning & bounds
`action` required	`enum`	analyze \| diff (two revisions -> impactDiff v1) \| bom one of "analyze", "diff", "bom", "package"
`limit` optional	`integer`	rows per analysis / impacts / BOM lines, worst first (default 20) ≥ 1 · ≤ 200
`offset` optional	`integer`	paging into the same order ≥ 0
`out` optional	`string`	also write the FULL result JSON here
`project` optional	`string \| object`	a path, or {repo,ref,path}; default: next to the board, same ref

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format-specific options (4 formats)

Format `analyze`

Argument	Type	Meaning & bounds
`ambientC` optional	`number`	thermal / ampacity ambient, C (default 25, ledgered)
`analyses` optional	`enum[]`	default: every analysis whose required inputs are present ≥ 1 items
`board` optional	`string \| object \| object`	a board: a path, {repo,ref,path} (git, no checkout) or {files}
`cert` optional	`object`	UL 796 / IPC-6012 / creepage inputs
`cert.altitudeM`	`number`	m ≥ 0
`cert.cti`	`number`	comparative tracking index, V ≥ 0
`cert.drillPositionTolMm`	`number`	mm ≥ 0
`cert.fab`	`string`	fab profile id, e.g. jlcpcb
`cert.innerRegistrationTolMm`	`number`	mm ≥ 0
`cert.ipcClass`	`enum`	— one of "2", "3", "3A", "DA"
`cert.laminate`	`string`	—
`cert.materialGroup`	`enum`	— one of "I", "II", "IIIa", "IIIb"
`cert.motC`	`number`	requested MOT, C
`cert.outerRegistrationTolMm`	`number`	mm ≥ 0
`cert.pairs`	`object[]`	creepage: net pairs and the voltage between them ≥ 1 items
`cert.pollutionDegree`	`integer`	— ≥ 1 · ≤ 3
`cert.rule`	`enum`	— one of "iec62368", "ipc2221"
`defaults` optional	`enum`	typical: cited typical values, ledgered; refuse: every gap is a refusal one of "typical", "refuse"
`jobMode` optional	`boolean`	true: return a job now; false: run inline even if large
`netClasses` optional	`object`	impedance targets per class: {<class>: {targetOhm, diffOhm, tolPct, nets}}
`nets` optional	`string[]`	restrict impedance / returnPath to these nets (glob allowed)
`power` optional	`object[]`	thermal: component dissipation ≥ 1 items
`rails` optional	`object[]`	dc / ampacity / thermal Joule heat: one entry per rail ≥ 1 items
`returnPath` optional	`object`	—
`returnPath.nets`	`string[]`	net names, glob allowed ("DDR_*")
`returnPath.riseTimeNs`	`number`	edge rise time, ns > 0
`stackup` optional	`object`	overrides the file's stackup
`stackup.copperUm`	`object`	copper thickness per layer name, um
`stackup.dielectric`	`object`	—
`stackup.layers`	`object[]`	the whole stackup, top to bottom ≥ 1 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `bom`

Argument	Type	Meaning & bounds
`board` optional	`string \| object \| object`	a board: a path, {repo,ref,path} (git, no checkout) or {files}
`schematic` optional	`string \| object`	a path, or {repo,ref,path}; default: next to the board, same ref

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `diff`

Argument	Type	Meaning & bounds
`after` optional	`string \| object \| object`	a board: a path, {repo,ref,path} (git, no checkout) or {files}
`ambientC` optional	`number`	thermal / ampacity ambient, C (default 25, ledgered)
`analyses` optional	`enum[]`	default: every analysis whose required inputs are present ≥ 1 items
`before` optional	`string \| object \| object`	a board: a path, {repo,ref,path} (git, no checkout) or {files}
`cert` optional	`object`	UL 796 / IPC-6012 / creepage inputs
`cert.altitudeM`	`number`	m ≥ 0
`cert.cti`	`number`	comparative tracking index, V ≥ 0
`cert.drillPositionTolMm`	`number`	mm ≥ 0
`cert.fab`	`string`	fab profile id, e.g. jlcpcb
`cert.innerRegistrationTolMm`	`number`	mm ≥ 0
`cert.ipcClass`	`enum`	— one of "2", "3", "3A", "DA"
`cert.laminate`	`string`	—
`cert.materialGroup`	`enum`	— one of "I", "II", "IIIa", "IIIb"
`cert.motC`	`number`	requested MOT, C
`cert.outerRegistrationTolMm`	`number`	mm ≥ 0
`cert.pairs`	`object[]`	creepage: net pairs and the voltage between them ≥ 1 items
`cert.pollutionDegree`	`integer`	— ≥ 1 · ≤ 3
`cert.rule`	`enum`	— one of "iec62368", "ipc2221"
`defaults` optional	`enum`	typical: cited typical values, ledgered; refuse: every gap is a refusal one of "typical", "refuse"
`jobMode` optional	`boolean`	true: return a job now; false: run inline even if large
`netClasses` optional	`object`	impedance targets per class: {<class>: {targetOhm, diffOhm, tolPct, nets}}
`nets` optional	`string[]`	restrict impedance / returnPath to these nets (glob allowed)
`power` optional	`object[]`	thermal: component dissipation ≥ 1 items
`rails` optional	`object[]`	dc / ampacity / thermal Joule heat: one entry per rail ≥ 1 items
`returnPath` optional	`object`	—
`returnPath.nets`	`string[]`	net names, glob allowed ("DDR_*")
`returnPath.riseTimeNs`	`number`	edge rise time, ns > 0
`schematic` optional	`string \| object`	a path, or {repo,ref,path}; default: next to the board, same ref
`stackup` optional	`object`	overrides the file's stackup
`stackup.copperUm`	`object`	copper thickness per layer name, um
`stackup.dielectric`	`object`	—
`stackup.layers`	`object[]`	the whole stackup, top to bottom ≥ 1 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `package`

Argument	Type	Meaning & bounds
`codesign` optional	`object`	action:package: {ballMap, footprint, opts} die/package/board check
`package` optional	`object \| string`	action:package -> cad_chip package (CADSF-100295): {fcbga\|chiplet\|hbm\|wirebond: spec}

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Returns no structured fields.

Exactly one of these argument shapes: action — or — spillPath + bytes + budgetBytes — or — error.

`cad_rtl` write RTL lint, simulate and coverage

Lint, simulate and cover Verilog/SystemVerilog.

Full description

lint: verilator file:line findings; sim: iverilog over a JSON test-vector table (or cocotb), per-test pass/fail, the first failing cycle with a waveform, optional VCD; cov: toggle coverage. Missing tools: tool_not_found; long sims run as async jobs.

Arguments common to every format

Argument	Type	Meaning & bounds
`action` required	`enum`	lint \| sim (test-vector table or cocotb) \| cov (toggle coverage of the sim) one of "lint", "sim", "cov"
`files` optional	`string[]`	Verilog / SystemVerilog source paths ≥ 1 items
`jobMode` optional	`boolean`	true: run as an async job; false: force inline (default: long sims auto-route to a job)
`sources` optional	`object`	{"name.v": "source text"} inline sources (alternative or addition to files)
`timeoutSec` optional	`integer`	per-process limit, default 120 ≥ 1 · ≤ 3600
`top` optional	`string`	top module name (required for sim / cov) length ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format-specific options (3 formats)

Format `cov`

Argument	Type	Meaning & bounds
`vcdOut` optional	`string`	write the VCD here (relative paths resolve against the output directory) length ≥ 1
`vectors` optional	`object`	{clock?, signals:{name:{dir:"input"\|"output", width?}}, vectors:[{test?, in:{sig:n}, expect:{sig:n}}]}: one row per cycle; inputs hold until changed; outputs are checked after the clock edge (no clock = combinational)

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `lint`

Argument	Type	Meaning & bounds
`maxFindings` optional	`integer`	— ≥ 1 · ≤ 500

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `sim`

Argument	Type	Meaning & bounds
`after` optional	`integer`	waveform cycles after it (default 2) ≥ 0 · ≤ 32
`before` optional	`integer`	waveform cycles before the first failure (default 3) ≥ 0 · ≤ 32
`cocotb` optional	`object`	run a cocotb test module instead of vectors
`cocotb.module`	`string`	— length ≥ 1
`cocotb.pythonPath`	`string`	— length ≥ 1
`cocotb.testcase`	`string`	— length ≥ 1
`vcdOut` optional	`string`	write the VCD here (relative paths resolve against the output directory) length ≥ 1
`vectors` optional	`object`	{clock?, signals:{name:{dir:"input"\|"output", width?}}, vectors:[{test?, in:{sig:n}, expect:{sig:n}}]}: one row per cycle; inputs hold until changed; outputs are checked after the clock edge (no clock = combinational)
`wave` optional	`boolean`	include a waveform excerpt even when the sim passes
`waveSignals` optional	`string[]`	signals (name or hierarchical suffix) for the waveform; default the testbench ports

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`action` required	`string`	—
`ok` required	`boolean`	—
`pass` optional	`boolean`	—

`cad_synth` write Yosys synthesis to a PDK

Synthesize Verilog to a PDK cell library with Yosys, after a clean cad_rtl lint.

Full description

Returns cells by type, area, flops, latch / loop / unmapped findings and the gate-level netlist. Missing yosys: tool_not_found; missing liberty: pdk_not_found.

Arguments common to every format

Argument	Type	Meaning & bounds
`pdk` required	`enum`	target standard-cell library one of "sky130_fd_sc_hd", "gf180mcu_fd_sc_mcu7t5v0", "sg13g2_stdcell"
`top` required	`string`	top module name length ≥ 1
`clock` optional	`object`	target clock: periodNs drives abc -D (timing-driven mapping)
`clock.periodNs`	`number`	— > 0
`clock.port`	`string`	— length ≥ 1
`files` optional	`string[]`	Verilog / SystemVerilog source paths ≥ 1 items
`jobMode` optional	`boolean`	true: run as an async job
`liberty` optional	`string`	liberty (.lib) path; default: found under pdkRoot / CADSOLVER_PDK_ROOT / PDK_ROOT length ≥ 1
`netlistOut` optional	`string`	write the gate-level Verilog here (relative paths resolve against the output directory) length ≥ 1
`pdkRoot` optional	`string`	directory holding the PDK checkout length ≥ 1
`sources` optional	`object`	{"name.v": "text"} inline sources
`statsOut` optional	`string`	write the stats / findings JSON here length ≥ 1
`timeoutSec` optional	`integer`	per-process limit, default 120 ≥ 1 · ≤ 3600

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format-specific options (3 formats)

Format `gf180mcu_fd_sc_mcu7t5v0`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `sg13g2_stdcell`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `sky130_fd_sc_hd`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`action` required	`string`	—
`ok` required	`boolean`	—

Import & export · 4

The formats the kernel reads and writes - STEP, IGES, Parasolid, SLDPRT, STL, glTF/GLB, 3MF, 3D PDF, DXF (in: the 2D profiles of a drawing as a sketch or, with a thickness, a flat part; out: wireframe, cut contour or flat pattern) - in and out of the same model, plus the repair pass for what comes in leaking.

`cad_import` write Import a CAD, mesh or PCB layout file

Import a STEP, IGES, Parasolid (.x_t/.x_b/.sldprt), ACIS SAT, or STL/OBJ mesh file and graft what it contains into this document; a .dxf drawing lands as a 2D sketch, or as an extruded flat part with thickness, or (mode "drawing") is split into its views, as is a vector .pdf drawing (mode "drawing" only); mode "pc…

Full description

b" reads a PCB layout… Call cad_help({tool:"cad_import"}) for the rest.

Argument	Type	Meaning & bounds
`path` required	`string`	— length ≥ 1
`annotate` optional	`boolean \| string`	a .dxf with mode…
`assembly` optional	`enum`	publish the file'… one of "occurrences", "parts"
`autoRemedy` optional	`boolean`	—
`configuration` optional	`integer \| string`	Which CONFIGURATI…
`content` optional	`string`	— length ≥ 1
`displayMesh` optional	`boolean`	—
`document` optional	`string`	handle or "new" length ≥ 1
`drawingView` optional	`object`	One view's curves…
`drawingView.view`	`string`	a view name or id… length ≥ 1
`drawingView.annotations`	`string[]`	annotation subtyp…
`drawingView.kinds`	`enum[]`	— ≥ 1 items
`drawingView.limit`	`integer`	— ≥ 1 · ≤ 5000
`drawingView.offset`	`integer`	— ≥ 0
`exactBrep` optional	`boolean`	—
`excludeLayers` optional	`string[]`	DXF only: layer n… ≥ 1 items · ≤ 4096 items
`files` optional	`string[]`	the files of ONE… ≥ 1 items · ≤ 4096 items
`format` optional	`enum`	default auto… one of "auto", "kicad_pcb", "gerber-set", "ipc2581", "odbpp"
`gapTol` optional	`number`	mm, default 0.01… > 0
`heal` optional	`boolean`	—
`healSimplify` optional	`boolean`	—
`healStitchTol` optional	`number`	— > 0
`healTighten` optional	`boolean`	—
`keepFailed` optional	`boolean`	—
`layers` optional	`string[]`	DXF only: layer n… ≥ 1 items · ≤ 4096 items
`layout` optional	`string`	paper-space layou… length ≥ 1
`mode` optional	`enum`	"pcb": read a PCB… one of "pcb", "drawing"
`options` optional	`object`	PCB build options…
`options.arcTol`	`number`	chord sag mm, def… > 0
`options.bodyPer`	`enum`	default layer_net… one of "layer_net", "layer", "net"
`options.check`	`boolean \| string`	checkLocal per bo…
`options.colour`	`boolean`	face colours by n…
`options.copperStacking`	`enum`	default: the file's one of "outside", "inside"
`options.cutout`	`object`	keep only the boa…
`options.dielectric`	`enum`	default embedded… one of "embedded", "conformal", "none"
`options.dropVoidsBelow`	`number`	fill voids under… ≥ 0
`options.exactDrills`	`boolean`	default true: dri…
`options.faceBudget`	`number`	refuse above this… > 0
`options.fillAllVias`	`boolean`	default false: bu…
`options.fillInner`	`boolean`	default true: die…
`options.fillThermalReliefs`	`any`	PCB [8/10], not b…
`options.keepUnnetted`	`boolean`	build copper on n…
`options.layers`	`string[]`	copper layers to…
`options.mergeVias`	`any`	PCB [8/10], not b…
`options.minDistance`	`number`	point merge / dri… ≥ 0
`options.minFeature`	`number`	drop islands unde… ≥ 0
`options.minTraceWidth`	`any`	PCB [8/10], not b…
`options.mirrorY`	`boolean`	y -> -y; default…
`options.nets`	`integer \| string[]`	nets to build: na…
`options.plating`	`number`	barrel wall mm, d… ≥ 0
`options.prism`	`enum`	default lean: pri… one of "lean", "extrude"
`options.removeNonFunctionalPads`	`any`	PCB [8/10], not b…
`options.removeSinglePinComponents`	`boolean`	default false: dr…
`options.stackup`	`object \| string`	Gerber: stackup.j…
`options.tolerant`	`boolean`	Gerber: an unread…
`options.viaMaxDrill`	`number`	Gerber without X2… > 0
`options.vias`	`enum`	default barrel… one of "barrel", "solid"
`page` optional	`integer`	a .pdf drawing on… ≥ 1
`saveCurves` optional	`string`	file path… length ≥ 1
`searchPaths` optional	`string[]`	Extra folders… ≥ 1 items · ≤ 64 items
`space` optional	`enum`	mode "drawing" on… one of "auto", "model", "paper"
`stitch` optional	`boolean`	—
`stitchTol` optional	`number`	— > 0
`structureOnly` optional	`boolean`	—
`subtree` optional	`string`	— length ≥ 1
`suppressed` optional	`boolean`	true = not built
`thickness` optional	`number`	mm — DXF only. > 0
`toBrep` optional	`boolean`	—
`tolerant` optional	`boolean`	—
`units` optional	`enum`	File length unit. one of "um", "mm", "cm", "m", "in", "ft"
`voxelSize` optional	`number`	— > 0
`wetted` optional	`boolean`	—
`wireframe` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_heal` write Heal body

REPAIR an imported body: stitch, then merge the duplicate topology the translator emitted, then re-sew the gaps that survive at a tolerance measured from the gaps themselves (ops/healPipeline.js).

Full description

Call cad_help({tool:"cad_heal"}) for the rest.

Argument	Type	Meaning & bounds
`of` required	`string`	body handle length ≥ 1
`document` optional	`string`	handle or "new" length ≥ 1
`keepFailed` optional	`boolean`	—
`simplify` optional	`boolean`	—
`stitchTol` optional	`number`	— > 0
`suppressed` optional	`boolean`	true = not built
`tighten` optional	`boolean`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_export_body` write Export a body to a file

Write a body (or the whole document) to a file in one of 21 formats; returns {path, bytes, format} + that format's report, never the contents.

Full description

Arguments are listed by name and type only; cad_help({tool:"cad_export_body", format}) gives one format's options. Call cad_help({tool:"cad_export_body"}) for the rest.

Arguments common to every format

Argument	Type	Meaning & bounds
`format` required	`enum`	Output file format. vehicle is a Space Program craft (ncsp.vehicle/1 folder or .zip; commercial seat) — CADSF-100529. picogk_stl is a watertight, normals-out binary STL in mm for LEAP 71 PicoGK, tessellated at voxelSize/4; vdb is the same body voxelised to OpenVDB by the optional picopie add-on (both need voxelSize) — CADSF-101045. ifc is IFC4, one element per body — CADSF-100415. x_t/x_b are Parasolid transmit (text/binary) — CADSF-741/742; 3mf is the core-spec additive package — CADSF-737; 3mf-bambu is the same package in the Bambu Studio project flavour (per-body filament slots, X1C profile, no "not from Bambu Lab" dialog) — CADSF-1774; 3mf-project is the vendor-neutral PrusaSlicer/OrcaSlicer project (one object per print, per-volume extruder) — CADSF-2501; 3mf-beamlattice is the 3MF Beam Lattice extension written from a strut list — CADSF-2127; ap242-xml is the AP242 domain-model XML assembly structure plus one .stp per part — CADSF-768; ply is binary PLY with shared (indexed) vertices, ~38% of a binary STL — CADSF-101149; fcstd is a native parametric FreeCAD 1.1 PartDesign document rebuilt from the whole op history, with fallbacks reported — CADSF-101947; qif is a QIF 3.0 inspection plan (characteristics, datums, plane/cylinder features) from the authored PMI of the document, refused when there is none — schema-unvalidated until the XSDs are installed. one of "stl", "step", "svg", "dxf", "contour-dxf", "flat-dxf", "pdf", "prc", "gltf", "glb", "usda", "usdz", "x_t", "x_b", "3mf", "3mf-bambu", "3mf-project", "3mf-beamlattice", "sat", "ap242-xml", "ifc", "picogk_stl", "vdb", "ply", "vehicle", "fcstd", "qif"
`path` required	`string`	Output file path. Absolute paths are used as-is; relative paths resolve against the configured output directory (cad_configure's outputDirectory / CADSOLVER_MCP_OUTPUT_DIR) when set, else the user's Documents folder (never the server process's cwd). Parent directories are created as needed.
`document` optional	`string`	A session document handle returned by an earlier modeling-tool call's "document" field — use this to target a document OTHER than the session's default (e.g. a second part built with a modeling call's {"document":"new"}). Omit to use the session's default/active document. length ≥ 1
`of` optional	`string`	"all" (every live body in the active document, merged) — the default — "<opId>" (body 0 of that op), or "<opId>#<bodyIndex>" (one body of a multi-body op). For format:"step", "all"/omitted still serializes the whole assembled document, but naming ONE body writes a STEP file containing ONLY that body (CADSB-144) — this is what lets two parts in the same document export as two separate STEP files without needing two documents; a "document":"new" modeling-tool call plus this tool's own "document" field is the OTHER way, for two parts you want to keep fully independent. default `"all"`
`strict` optional	`boolean`	CADSF-1377. Multi-body sets only. false/omitted (default): the finishing check's report rides the result as an "assembly" block and anything wrong is a WARNING — the file is still written. true: a part that floats, interpenetrates another part, or does not sit on z=0 (within 0.5 mm, for the parts that reach lowest) REFUSES the call as E_ASSEMBLY_UNSOUND before anything is written, with the same report in details.assembly. Use it as a release gate.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format-specific options (27 formats)

Format `3mf`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`hybrid` optional	`enum`	3mf, lattice_fill hybrid body: one fused mesh (default) or split = 2 objects, exact shell + lattice core. one of "fused", "split"
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`resolution` optional	`enum`	stl/3mf/ply of a lattice_fill field body (CADSF-101149): "full" (default) is the extraction as before; "print" decimates it within 0.02-0.05 mm of the true surface (adaptive to the thinnest wall; walls thin <= 3%), still watertight, 3MF coordinates at 1 um. Result exportProfile: bytes/triangles before and after. Over the in-memory budget (2M triangles) "print" streams chunk by chunk (CADSF-101300: seam vertices locked; result streamed:true). one of "full", "print" · default `"full"`
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `3mf-bambu`

Argument	Type	Meaning & bounds
`bambu` optional	`object`	3mf-bambu only (CADSF-1774): the Bambu project options. Everything is optional — with none of it the export is a single plate of PLA on slot 1 for a "Bambu Lab X1 Carbon" 0.4 nozzle with the stock 0.20mm Standard process.
`bambu.allowFloating`	`boolean`	CADSF-2282: write objects floating above the plate as-is (refused/dropped by default).
`bambu.allowMirror`	`boolean`	CADSF-2285: allow det<0 (mirroring) transforms.
`bambu.allowMixedMaterials`	`boolean`	CADSB-1437: allow PLA-family and ABS-family slots on one print (refused by default).
`bambu.application`	`string`	Override the Application metadata string. See BambuThreeMfWriter.js for exactly which reader check it is believed to satisfy.
`bambu.assemble`	`boolean \| enum`	CADSF-2250: "auto" (default) writes bodies that touch or overlap as ONE Bambu object with each body a part (own slot), so Studio slices them as one print and runs no path-conflict check between them; "all" = one object; false = one object per body.
`bambu.assembleGap`	`number`	CADSF-2250: how close (mm) two bodies' boxes must come for "auto" to join them. Default 0.05. ≥ 0
`bambu.bedType`	`string`	Bed type for every plate that does not name its own.
`bambu.filaments`	`object[]`	One entry per AMS slot, in slot order (slot 1 first). ≥ 1 items
`bambu.force`	`boolean`	Export a body the manifold gate refuses anyway, letting the slicer run its own repair.
`bambu.lenientKeys`	`boolean`	CADSF-2286: ignore slots/transforms keys naming no body (refused by default).
`bambu.maxSlots`	`integer`	Slot ceiling (default 16). One AMS is 4. ≥ 1
`bambu.plates`	`object[]`	Multi-plate layout. One plate holding every body when omitted. ≥ 1 items
`bambu.primeTower`	`boolean \| enum`	CADSB-1438: "auto" (default) turns the prime tower on only when some layer holds two filaments.
`bambu.printSequence`	`string`	Print sequence for every plate that does not name its own.
`bambu.printer`	`object`	—
`bambu.projectSettings`	`object`	Extra project_settings.config keys, merged last.
`bambu.slotByColour`	`object`	Explicit "#RRGGBB" -> 1-based filament slot.
`bambu.slots`	`object`	Explicit body NAME -> 1-based filament slot. Beats every colour rule.
`bambu.splitObjects`	`boolean`	true puts each mesh in its own 3D/Objects/object_N.model part, the way Bambu Studio splits a large project. Our own 3MF reader does not follow cross-part components, so the default (false) is the single-part form both read.
`bambu.supportOnBuildPlateOnly`	`boolean`	Default true: supports only grow from the bed, never inside print-in-place gaps.
`bambu.supportType`	`enum`	Support style when supports are on. Default tree(auto). one of "tree(auto)", "normal(auto)", "tree(manual)", "normal(manual)"
`bambu.supports`	`boolean \| enum`	CADSB-1436/CADSF-2160: "auto" (default) turns support on when the bodies overhang past 30° (tree(auto), build plate only); true/false force it. The decision and why are in the result.
`bambu.thumbnails`	`boolean`	false omits the placeholder PNGs (and the OPC thumbnail relationship).
`bambu.transforms`	`object`	Body NAME -> ROW-MAJOR 4x4 (translation in the last column), the print orientation CADSF-1773 computes. Identity when omitted.
`bambu.units`	`string`	Millimetres only — a Bambu project has no other unit. Anything else is refused by name.
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `3mf-beamlattice`

Argument	Type	Meaning & bounds
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`struts` optional	`object[]`	3mf-beamlattice only (CADSF-2127): the strut list — [{p0:[x,y,z], p1:[x,y,z], r}] with optional r0/r1 (end radii, a tapered beam), cap/cap0/cap1 ("sphere" \| "hemisphere" \| "butt") and family (one beam set per family), ops/latticeCell.js's shape. "of" then names the solid the lattice FILLS, whose tessellation becomes the clipping mesh; omit "of" (or "all") for no clipping. ≥ 1 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `3mf-project`

Argument	Type	Meaning & bounds
`bambu` optional	`object`	3mf-bambu only (CADSF-1774): the Bambu project options. Everything is optional — with none of it the export is a single plate of PLA on slot 1 for a "Bambu Lab X1 Carbon" 0.4 nozzle with the stock 0.20mm Standard process.
`bambu.allowFloating`	`boolean`	CADSF-2282: write objects floating above the plate as-is (refused/dropped by default).
`bambu.allowMirror`	`boolean`	CADSF-2285: allow det<0 (mirroring) transforms.
`bambu.allowMixedMaterials`	`boolean`	CADSB-1437: allow PLA-family and ABS-family slots on one print (refused by default).
`bambu.application`	`string`	Override the Application metadata string. See BambuThreeMfWriter.js for exactly which reader check it is believed to satisfy.
`bambu.assemble`	`boolean \| enum`	CADSF-2250: "auto" (default) writes bodies that touch or overlap as ONE Bambu object with each body a part (own slot), so Studio slices them as one print and runs no path-conflict check between them; "all" = one object; false = one object per body.
`bambu.assembleGap`	`number`	CADSF-2250: how close (mm) two bodies' boxes must come for "auto" to join them. Default 0.05. ≥ 0
`bambu.bedType`	`string`	Bed type for every plate that does not name its own.
`bambu.filaments`	`object[]`	One entry per AMS slot, in slot order (slot 1 first). ≥ 1 items
`bambu.force`	`boolean`	Export a body the manifold gate refuses anyway, letting the slicer run its own repair.
`bambu.lenientKeys`	`boolean`	CADSF-2286: ignore slots/transforms keys naming no body (refused by default).
`bambu.maxSlots`	`integer`	Slot ceiling (default 16). One AMS is 4. ≥ 1
`bambu.plates`	`object[]`	Multi-plate layout. One plate holding every body when omitted. ≥ 1 items
`bambu.primeTower`	`boolean \| enum`	CADSB-1438: "auto" (default) turns the prime tower on only when some layer holds two filaments.
`bambu.printSequence`	`string`	Print sequence for every plate that does not name its own.
`bambu.printer`	`object`	—
`bambu.projectSettings`	`object`	Extra project_settings.config keys, merged last.
`bambu.slotByColour`	`object`	Explicit "#RRGGBB" -> 1-based filament slot.
`bambu.slots`	`object`	Explicit body NAME -> 1-based filament slot. Beats every colour rule.
`bambu.splitObjects`	`boolean`	true puts each mesh in its own 3D/Objects/object_N.model part, the way Bambu Studio splits a large project. Our own 3MF reader does not follow cross-part components, so the default (false) is the single-part form both read.
`bambu.supportOnBuildPlateOnly`	`boolean`	Default true: supports only grow from the bed, never inside print-in-place gaps.
`bambu.supportType`	`enum`	Support style when supports are on. Default tree(auto). one of "tree(auto)", "normal(auto)", "tree(manual)", "normal(manual)"
`bambu.supports`	`boolean \| enum`	CADSB-1436/CADSF-2160: "auto" (default) turns support on when the bodies overhang past 30° (tree(auto), build plate only); true/false force it. The decision and why are in the result.
`bambu.thumbnails`	`boolean`	false omits the placeholder PNGs (and the OPC thumbnail relationship).
`bambu.transforms`	`object`	Body NAME -> ROW-MAJOR 4x4 (translation in the last column), the print orientation CADSF-1773 computes. Identity when omitted.
`bambu.units`	`string`	Millimetres only — a Bambu project has no other unit. Anything else is refused by name.
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `ap242-xml`

Argument	Type	Meaning & bounds
`colors` optional	`object`	US spelling of "colours" (same map) ≥ 1 keys
`colours` optional	`object`	step / ap242-xml / x_t (CADSF-2886): body colours, { "<body ref \| op id \| part name>": "#RRGGBB" \| [r,g,b] }. Each named body is written with one STYLED_ITEM/COLOUR_RGB (STEP) or SDL/TYSA_COLOUR (x_t), and the colour stays on the document for later exports. Colours already on the document (an imported file's, earlier calls') are always written, with or without this. A key naming no body is refused COLOUR_NO_BODY. ≥ 1 keys
`transforms` optional	`object`	STEP export only ("format":"step"): a per-body placement to write into the exported product structure, keyed by the same body reference "of" accepts (a handle, "<opId>", or "<opId>#<n>") — one entry per body that needs to move. This is the seam that turns a solved mate set into an assembled export: paste cad_assembly_mate's own per-component `cadTransform` ({ rotate: { axis, angle } \| null, translate }, about the world origin) straight in as the value for that component's body ref — or pass the lower-level affine { m, t } form (a 3x3 rotation matrix + translation) if you built the placement some other way. A body named here gets its own PRODUCT/NAUO placement in the file instead of the shared identity one every other body keeps; only takes effect when the export covers more than one body (a single-body export has no assembly structure to place anything in). Refused for stl/svg/dxf.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `contour-dxf`

Argument	Type	Meaning & bounds
`axis` optional	`enum`	SVG/DXF/contour-DXF only: which world axis to project along (drop) — "z" is a top/plan view. "auto" (contour-dxf only) picks the axis the part is thinnest along, i.e. the sheet normal. one of "x", "y", "z", "auto" · default `"z"`
`side` optional	`enum`	contour-dxf only: take the contour from the face at the HIGH end of the view axis ("near", the default) or the low end ("far"). Only matters when the two faces differ. one of "near", "far" · default `"near"`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `dxf`

Argument	Type	Meaning & bounds
`axis` optional	`enum`	SVG/DXF/contour-DXF only: which world axis to project along (drop) — "z" is a top/plan view. "auto" (contour-dxf only) picks the axis the part is thinnest along, i.e. the sheet normal. one of "x", "y", "z", "auto" · default `"z"`
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`units` optional	`enum`	x_t/x_b (CADSB-818): the unit the transmit's own numbers are written in, "m" or "mm". Default "m" — Parasolid's convention [S §4.2.1], the one every vendor transmit in this repo's corpus uses, so the file opens at the right size in SolidWorks/NX. Pass "mm" only to reproduce the pre-CADSB-818 byte shape (kernel mm written unscaled). dxf (CADSF-100617, wireframe and "view":"hlr"): the unit the drawing is written in — every coordinate is CONVERTED from the kernel's millimetres and the header declares it ($INSUNITS, with $MEASUREMENT). Default "mm", byte-identical coordinates to before; the document's declared import unit is not applied by itself, pass it here to get that unit. cm/in/ft/um are dxf only; contour-dxf and flat-dxf are always millimetres, and no other format takes a unit. one of "m", "mm", "cm", "in", "ft", "um"
`view` optional	`enum`	SVG/DXF only (CADSF-770): "wireframe" (default, unchanged) draws every tessellated-mesh edge with no occlusion test — see wireframe.js. "hlr" reuses ops/hlr.js's vector hidden-line-removal pipeline (CADSF-115): the body's real B-rep edges plus view-dependent silhouettes on curved faces (analytic where the surface is a plane/cylinder/cone/sphere/torus, tessellation-derived otherwise), occlusion-tested against the tessellated mesh via BVH raycast and split into visible/hidden runs — a drafting-grade view instead of a mesh dump: visible edges solid, hidden edges dashed on their own layer/group ("VISIBLE"/"HIDDEN" in DXF, id="visible"/id="hidden" groups in SVG). Reads "axis" for the camera direction the same three principal views wireframe mode offers ("auto" is not meaningful here and is treated as "z"); the response reports "visibleEdgeCount"/"hiddenEdgeCount" alongside the usual "edgeCount" (their sum). Refused for every format other than svg/dxf. one of "wireframe", "hlr"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `fcstd`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `flat-dxf`

Argument	Type	Meaning & bounds
`kFactor` optional	`number`	flat-dxf only: K-factor override for the developed length — the neutral-axis position as a fraction of thickness from the INSIDE surface, (0, 0.5]. Omit for the published air-bending R/T table. The DXF's TEXT layer records what was used per bend. > 0 · ≤ 0.5

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `glb`

Argument	Type	Meaning & bounds
`animations` optional	`object[]`	gltf/glb only: authored node-TRS animation clips, passed through to the writer verbatim (kinematic SAMPLING from a solved mate set is CADSF-751, not this argument). Channel "node" indices address the exported scene's nodes: with bakeTransforms:true body i is node i; otherwise node 0 is the conversion root and body i is node i+1. "times" are seconds, strictly ascending; "values" is one [x,y,z] per key ([x,y,z,w] for "rotation"). ≥ 1 items
`bakeTransforms` optional	`boolean`	gltf/glb only: true bakes the mm→m scale and Z-up→Y-up rotation into the vertex buffers themselves; false (default) ships kernel-space coordinates under one root conversion node carrying that scale and rotation, so downstream tooling can still read kernel-space mm out of the buffers. default `false`
`compression` optional	`object`	gltf/glb only (CADSF-981, on CADSF-752's GltfCompression): shrink the written container. BOTH FLAGS DEFAULT OFF — omit this object and the file is byte-for-byte the uncompressed CADSF-753 export. Applied between the scene build and the encode, so it composes with "lods", "envelope" and authored "animations". Both extensions are declared in extensionsUsed AND extensionsRequired (a viewer that cannot decode them must refuse the file rather than draw it wrong), and both are read back by our own reader (web/src/glb-read.js) and poster renderer. Draco and meshopt are NOT here: each extension is defined by its encoder (a C++/WASM dependency), and neither is installed — ask for them and GltfCompression refuses by name.
`compression.instance`	`boolean`	Write EXT_mesh_gpu_instancing: childless, matrix-free sibling nodes that share one mesh collapse into a single node carrying a TRANSLATION/ROTATION/SCALE accessor per instance. Animated nodes, MSFT_lod nodes and the root are never collapsed, so a LOD ladder and authored clips survive.
`compression.minInstances`	`integer`	Group size at which collapsing pays (default 4). Below it the nodes are left alone, because an instance accessor costs a buffer view. ≥ 2
`compression.quantize`	`boolean`	Write KHR_mesh_quantization: POSITION -> SHORT on a per-mesh power-of-two grid whose inverse is folded into the node transform, NORMAL -> normalized SHORT, TEXCOORD_0 -> normalized UNSIGNED_SHORT when the uvs stay in [0, 1]. Roughly a third off a geometry-heavy part. On a NODE-heavy scene quantization alone can GROW the file (every drawing node gains a dequantization transform) — pair it with "instance" there.
`creaseAngleDeg` optional	`number`	gltf/glb only (CADSF-753): crease gate in degrees for the tessellator's shading-normal pass (CADSB-472) — edges whose faces meet more smoothly than this are welded to one shared normal, sharper ones keep a hard crease (duplicated rim vertices). SceneReady spec §4 default is 30. This gate is what makes a runtime renderer shade the part correctly instead of flat faces as gradients (CADSB-514). > 0 · ≤ 180 · default `30`
`envelope` optional	`boolean`	gltf/glb only (CADSF-757): Envelope Export — ship only the bodies that participate in the model's exterior appearance; bodies that cannot be seen from outside are left out of the file entirely (smaller asset, and internal mechanisms never leave the source document). The result's "envelope" field reports what was kept and what stayed home. A body that must ship regardless belongs in "of".
`envelopeViews` optional	`number`	gltf/glb only: sampling quality for envelope:true (default 26, minimum 20). Raise it if a body visible only through a small opening must survive the cut.
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`lodMode` optional	`enum`	gltf/glb only (CADSF-776), and only alongside "lods". "single" (default): ONE container holding every level, wired with the MSFT_lod vendor extension — the chain hangs off each highest-detail body node as extensions.MSFT_lod.ids (node indices of the lower levels, finest first) with extras.MSFT_screencoverage carrying the switch thresholds, and "MSFT_lod" declared in extensionsUsed. The lower-level nodes are reachable ONLY through those ids — not in the scene, not anyone's child — so a viewer that does not implement the extension loads the highest level and ignores the rest instead of drawing N overlapping copies. "files": N independent assets written beside the requested path as "<name>.lod0.glb", "<name>.lod1.glb", …, each a complete single-level scene with no MSFT_lod — the shape a streaming/CDN pipeline wants. Either way the response's "lod.levels" reports every file, budget and achieved triangle count. one of "single", "files"
`lods` optional	`object[]`	gltf/glb only (CADSF-776): export N TESSELLATION LEVELS in this one call instead of one budgeted mesh — the LOD chain a game engine or digital twin actually wants. Each entry is one level's budget ("tolerance" mm chord and/or "maxTriangles"), listed FINEST FIRST; a list that runs coarse→fine is refused, not reordered. The top-level "tolerance"/"maxTriangles" are refused alongside this (one source of truth per number). Levels go through the honest CADSB-155 budget search (subdivision, then the chord-tolerance ladder), so the response's "lod" reports the triangle count each level ACHIEVED, the method, a per-level "shortfall" flag when even the coarsest achievable mesh missed the budget, and "monotonic" — whether counts really do fall level over level (chord tolerance only moves ANALYTIC curved faces; prebuilt faceted faces such as gear flanks, and planar faces, do not coarsen at all, so a badly chosen ladder can flatten out). See "lodMode" for the two shipping shapes. ≥ 2 items · ≤ 8 items
`material` optional	`object \| string`	gltf/glb only (CADSF-1202): a default KHR_materials_pbrMetallicRoughness material for a BARE body — one with no "materialsOverride"/authored per-face appearance. Either a named stock ("6061-T6", "ti-6al-4v", "in718", "ss-304", "ss-316", "mild-steel", "brass-c360", "abs", "pla", "pa12", "acrylic" — see exporters/materials.js STOCKS for the full table and each colour/roughness citation) resolved through GltfExporter's stock table, or a full PBR object ({baseColorFactor:[r,g,b,a], metallicFactor, roughnessFactor, name?} or a raw glTF material with "pbrMetallicRoughness"). Emitted ONCE and referenced by every primitive that does not already carry its own "material" index (materialsOverride wins per-body); an unrecognised stock name is refused (not guessed), listing every known stock. Without it, output is byte-identical to before this ticket — this is what let CADSB-746's imts-casing page drop its viewer-side fallback override once the shipped GLB carries a real material.
`materialsOverride` optional	`object[]`	gltf/glb only: glTF 2.0 material objects, passed through verbatim (kernel appearance→PBR mapping is CADSF-749; this is the manual override until then, and the override of it after). Pass ONE material (applied to every exported body) or exactly one per body in "of" resolution order — any other count is refused rather than guessed at. ≥ 1 items
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`quantize` optional	`boolean`	gltf/glb only: shorthand for compression:{quantize:true} (CADSF-981). Pass the object form when you also want "instance".
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tangents` optional	`boolean`	gltf/glb: also write TANGENT (VEC4) on TEXCOORD_0. Default false.
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`uv` optional	`enum`	gltf/glb/usd: texture coordinates. "game" (default, SceneReady): TEXCOORD_0 metric (1 uv = 1 m or "uvScale" mm, tiling) + TEXCOORD_1 packed non-overlapping 0-1 atlas (bakes, decals). No images; materials carry extras.materialClass/paletteId. "normalized": per-face [0,1]². "world": fixed physical size. "none": no uvs. UVs duplicate seam/face-boundary vertices; report in asset.extras.conversion.uv. Format: docs/FORMATS.md. one of "game", "normalized", "world", "none" · default `"game"`
`uvAtlasPx` optional	`integer`	uv:"game": TEXCOORD_1 atlas size in texels (default 1024; 4-texel gutter). ≥ 64 · ≤ 16384
`uvScale` optional	`number`	gltf/glb/usd: mm of surface per uv unit — uv:"game" (default 1000, never snapped) or uv:"world" (default 10, snapped to whole tiles per revolution).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `gltf`

Argument	Type	Meaning & bounds
`animations` optional	`object[]`	gltf/glb only: authored node-TRS animation clips, passed through to the writer verbatim (kinematic SAMPLING from a solved mate set is CADSF-751, not this argument). Channel "node" indices address the exported scene's nodes: with bakeTransforms:true body i is node i; otherwise node 0 is the conversion root and body i is node i+1. "times" are seconds, strictly ascending; "values" is one [x,y,z] per key ([x,y,z,w] for "rotation"). ≥ 1 items
`bakeTransforms` optional	`boolean`	gltf/glb only: true bakes the mm→m scale and Z-up→Y-up rotation into the vertex buffers themselves; false (default) ships kernel-space coordinates under one root conversion node carrying that scale and rotation, so downstream tooling can still read kernel-space mm out of the buffers. default `false`
`compression` optional	`object`	gltf/glb only (CADSF-981, on CADSF-752's GltfCompression): shrink the written container. BOTH FLAGS DEFAULT OFF — omit this object and the file is byte-for-byte the uncompressed CADSF-753 export. Applied between the scene build and the encode, so it composes with "lods", "envelope" and authored "animations". Both extensions are declared in extensionsUsed AND extensionsRequired (a viewer that cannot decode them must refuse the file rather than draw it wrong), and both are read back by our own reader (web/src/glb-read.js) and poster renderer. Draco and meshopt are NOT here: each extension is defined by its encoder (a C++/WASM dependency), and neither is installed — ask for them and GltfCompression refuses by name.
`compression.instance`	`boolean`	Write EXT_mesh_gpu_instancing: childless, matrix-free sibling nodes that share one mesh collapse into a single node carrying a TRANSLATION/ROTATION/SCALE accessor per instance. Animated nodes, MSFT_lod nodes and the root are never collapsed, so a LOD ladder and authored clips survive.
`compression.minInstances`	`integer`	Group size at which collapsing pays (default 4). Below it the nodes are left alone, because an instance accessor costs a buffer view. ≥ 2
`compression.quantize`	`boolean`	Write KHR_mesh_quantization: POSITION -> SHORT on a per-mesh power-of-two grid whose inverse is folded into the node transform, NORMAL -> normalized SHORT, TEXCOORD_0 -> normalized UNSIGNED_SHORT when the uvs stay in [0, 1]. Roughly a third off a geometry-heavy part. On a NODE-heavy scene quantization alone can GROW the file (every drawing node gains a dequantization transform) — pair it with "instance" there.
`creaseAngleDeg` optional	`number`	gltf/glb only (CADSF-753): crease gate in degrees for the tessellator's shading-normal pass (CADSB-472) — edges whose faces meet more smoothly than this are welded to one shared normal, sharper ones keep a hard crease (duplicated rim vertices). SceneReady spec §4 default is 30. This gate is what makes a runtime renderer shade the part correctly instead of flat faces as gradients (CADSB-514). > 0 · ≤ 180 · default `30`
`envelope` optional	`boolean`	gltf/glb only (CADSF-757): Envelope Export — ship only the bodies that participate in the model's exterior appearance; bodies that cannot be seen from outside are left out of the file entirely (smaller asset, and internal mechanisms never leave the source document). The result's "envelope" field reports what was kept and what stayed home. A body that must ship regardless belongs in "of".
`envelopeViews` optional	`number`	gltf/glb only: sampling quality for envelope:true (default 26, minimum 20). Raise it if a body visible only through a small opening must survive the cut.
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`lodMode` optional	`enum`	gltf/glb only (CADSF-776), and only alongside "lods". "single" (default): ONE container holding every level, wired with the MSFT_lod vendor extension — the chain hangs off each highest-detail body node as extensions.MSFT_lod.ids (node indices of the lower levels, finest first) with extras.MSFT_screencoverage carrying the switch thresholds, and "MSFT_lod" declared in extensionsUsed. The lower-level nodes are reachable ONLY through those ids — not in the scene, not anyone's child — so a viewer that does not implement the extension loads the highest level and ignores the rest instead of drawing N overlapping copies. "files": N independent assets written beside the requested path as "<name>.lod0.glb", "<name>.lod1.glb", …, each a complete single-level scene with no MSFT_lod — the shape a streaming/CDN pipeline wants. Either way the response's "lod.levels" reports every file, budget and achieved triangle count. one of "single", "files"
`lods` optional	`object[]`	gltf/glb only (CADSF-776): export N TESSELLATION LEVELS in this one call instead of one budgeted mesh — the LOD chain a game engine or digital twin actually wants. Each entry is one level's budget ("tolerance" mm chord and/or "maxTriangles"), listed FINEST FIRST; a list that runs coarse→fine is refused, not reordered. The top-level "tolerance"/"maxTriangles" are refused alongside this (one source of truth per number). Levels go through the honest CADSB-155 budget search (subdivision, then the chord-tolerance ladder), so the response's "lod" reports the triangle count each level ACHIEVED, the method, a per-level "shortfall" flag when even the coarsest achievable mesh missed the budget, and "monotonic" — whether counts really do fall level over level (chord tolerance only moves ANALYTIC curved faces; prebuilt faceted faces such as gear flanks, and planar faces, do not coarsen at all, so a badly chosen ladder can flatten out). See "lodMode" for the two shipping shapes. ≥ 2 items · ≤ 8 items
`material` optional	`object \| string`	gltf/glb only (CADSF-1202): a default KHR_materials_pbrMetallicRoughness material for a BARE body — one with no "materialsOverride"/authored per-face appearance. Either a named stock ("6061-T6", "ti-6al-4v", "in718", "ss-304", "ss-316", "mild-steel", "brass-c360", "abs", "pla", "pa12", "acrylic" — see exporters/materials.js STOCKS for the full table and each colour/roughness citation) resolved through GltfExporter's stock table, or a full PBR object ({baseColorFactor:[r,g,b,a], metallicFactor, roughnessFactor, name?} or a raw glTF material with "pbrMetallicRoughness"). Emitted ONCE and referenced by every primitive that does not already carry its own "material" index (materialsOverride wins per-body); an unrecognised stock name is refused (not guessed), listing every known stock. Without it, output is byte-identical to before this ticket — this is what let CADSB-746's imts-casing page drop its viewer-side fallback override once the shipped GLB carries a real material.
`materialsOverride` optional	`object[]`	gltf/glb only: glTF 2.0 material objects, passed through verbatim (kernel appearance→PBR mapping is CADSF-749; this is the manual override until then, and the override of it after). Pass ONE material (applied to every exported body) or exactly one per body in "of" resolution order — any other count is refused rather than guessed at. ≥ 1 items
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`quantize` optional	`boolean`	gltf/glb only: shorthand for compression:{quantize:true} (CADSF-981). Pass the object form when you also want "instance".
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tangents` optional	`boolean`	gltf/glb: also write TANGENT (VEC4) on TEXCOORD_0. Default false.
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`uv` optional	`enum`	gltf/glb/usd: texture coordinates. "game" (default, SceneReady): TEXCOORD_0 metric (1 uv = 1 m or "uvScale" mm, tiling) + TEXCOORD_1 packed non-overlapping 0-1 atlas (bakes, decals). No images; materials carry extras.materialClass/paletteId. "normalized": per-face [0,1]². "world": fixed physical size. "none": no uvs. UVs duplicate seam/face-boundary vertices; report in asset.extras.conversion.uv. Format: docs/FORMATS.md. one of "game", "normalized", "world", "none" · default `"game"`
`uvAtlasPx` optional	`integer`	uv:"game": TEXCOORD_1 atlas size in texels (default 1024; 4-texel gutter). ≥ 64 · ≤ 16384
`uvScale` optional	`number`	gltf/glb/usd: mm of surface per uv unit — uv:"game" (default 1000, never snapped) or uv:"world" (default 10, snapped to whole tiles per revolution).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `ifc`

Argument	Type	Meaning & bounds
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `pdf`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`pdfa` optional	`enum`	pdf only (CADSF-729): write an ARCHIVAL container instead of a plain 3D PDF — XMP conformance claim, output intent with an embedded ICC profile, trailer /ID, no unembedded font (the page caption is dropped), and the source AP242 STEP plus a per-part validation report embedded as associated files. "3b" is ISO 19005-3 (PDF/A-3B), which is what a records group asks for BUT whose permitted-annotation list does not include /3D — a 3D PDF cannot validate at that level, and the call returns a warning saying so. "4e" is ISO 19005-4E, the engineering level that permits 3D artwork: use it when the file has to be both rotatable and valid. one of "3b", "4e"
`pmiFrom` optional	`string`	pdf/prc only (CADSF-695): path to an AP242 STEP file whose GRAPHICAL PMI (tessellated annotation polylines — leaders, extension lines, callout glyph outlines) is read and written into the PRC as markup entities, with its saved camera(s) added to the PDF view list. Usually the same file the body was imported from; the importer does not retain its source path, so it is named explicitly.
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`stepFrom` optional	`string`	pdf only (CADSF-729), with "pdfa": path to the authoritative AP242 STEP to embed VERBATIM as the /AFRelationship /Source attachment — normally the file the body was imported from. Omitted, the document is written to AP242 with StepWriter and that is embedded instead.
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `picogk_stl`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`voxelSize` optional	`number`	picogk_stl / vdb only (CADSF-101045): the PicoGK voxel size in mm the file is prepared for. Sets the default chord tolerance (voxelSize/4) and, for vdb, the grid pitch. > 0 · ≤ 100

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `ply`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`resolution` optional	`enum`	stl/3mf/ply of a lattice_fill field body (CADSF-101149): "full" (default) is the extraction as before; "print" decimates it within 0.02-0.05 mm of the true surface (adaptive to the thinnest wall; walls thin <= 3%), still watertight, 3MF coordinates at 1 um. Result exportProfile: bytes/triangles before and after. Over the in-memory budget (2M triangles) "print" streams chunk by chunk (CADSF-101300: seam vertices locked; result streamed:true). one of "full", "print" · default `"full"`
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `prc`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`pmiFrom` optional	`string`	pdf/prc only (CADSF-695): path to an AP242 STEP file whose GRAPHICAL PMI (tessellated annotation polylines — leaders, extension lines, callout glyph outlines) is read and written into the PRC as markup entities, with its saved camera(s) added to the PDF view list. Usually the same file the body was imported from; the importer does not retain its source path, so it is named explicitly.
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `qif`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `sat`

No options beyond the arguments above.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `step`

Argument	Type	Meaning & bounds
`colors` optional	`object`	US spelling of "colours" (same map) ≥ 1 keys
`colours` optional	`object`	step / ap242-xml / x_t (CADSF-2886): body colours, { "<body ref \| op id \| part name>": "#RRGGBB" \| [r,g,b] }. Each named body is written with one STYLED_ITEM/COLOUR_RGB (STEP) or SDL/TYSA_COLOUR (x_t), and the colour stays on the document for later exports. Colours already on the document (an imported file's, earlier calls') are always written, with or without this. A key naming no body is refused COLOUR_NO_BODY. ≥ 1 keys
`compress` optional	`boolean`	step only (CADSF-100995): write the file gzipped — compressed STEP ("STEP-Zip"), what CATIA, SolidWorks, NX and most PDM systems open as .stpZ. A path ending in .stpZ / .stpz does this without the flag. "bytes" is then the compressed size and "uncompressedBytes" the Part 21 text. Refused for every other format (STEP_COMPRESS_FORMAT).
`schema` optional	`string`	step only (CADSF-100990): the STEP application protocol / edition the file declares — "ap203" (= ap203e2), "ap203e1", "ap203e2", "ap214", "ap242" (= ap242e2, the default), "ap242e1", "ap242e2", "ap242e3", or "source" (keep the document's own). What a schema cannot carry (PMI and tessellation outside AP242; colours, layers and validation properties in AP203 ed1) is dropped and listed on the result's "schema"; with "strict":true it is refused E_STEP_SCHEMA_UNSUPPORTED instead, nothing written. Refused for every other format (STEP_SCHEMA_FORMAT). pattern `^(ap203e1\|ap203e2\|ap214\|ap242e1\|ap242e2\|ap242e3\|ap203\|ap242\|source)$`
`tessellated` optional	`enum`	step only (CADSF-100394): AP242 tessellation of each body — "add" writes it beside the exact B-rep (a hybrid file: CAD reads the B-rep, a viewer the mesh), "only" instead of it (a viewer/LOTAR payload). Both write CAx-IF tessellated validation properties (facet count, mesh area, its centre point). Default "none": the B-rep alone, byte for byte as before. Refused for every other format (STEP_TESS_FORMAT). one of "none", "add", "only"
`transforms` optional	`object`	STEP export only ("format":"step"): a per-body placement to write into the exported product structure, keyed by the same body reference "of" accepts (a handle, "<opId>", or "<opId>#<n>") — one entry per body that needs to move. This is the seam that turns a solved mate set into an assembled export: paste cad_assembly_mate's own per-component `cadTransform` ({ rotate: { axis, angle } \| null, translate }, about the world origin) straight in as the value for that component's body ref — or pass the lower-level affine { m, t } form (a 3x3 rotation matrix + translation) if you built the placement some other way. A body named here gets its own PRODUCT/NAUO placement in the file instead of the shared identity one every other body keeps; only takes effect when the export covers more than one body (a single-body export has no assembly structure to place anything in). Refused for stl/svg/dxf.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `stl`

Argument	Type	Meaning & bounds
`binary` optional	`boolean`	STL only: true (default) for binary STL, false for streamed ASCII STL. (For glTF, binary is the format choice itself: "glb".) default `true`
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`resolution` optional	`enum`	stl/3mf/ply of a lattice_fill field body (CADSF-101149): "full" (default) is the extraction as before; "print" decimates it within 0.02-0.05 mm of the true surface (adaptive to the thinnest wall; walls thin <= 3%), still watertight, 3MF coordinates at 1 um. Result exportProfile: bytes/triangles before and after. Over the in-memory budget (2M triangles) "print" streams chunk by chunk (CADSF-101300: seam vertices locked; result streamed:true). one of "full", "print" · default `"full"`
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `svg`

Argument	Type	Meaning & bounds
`axis` optional	`enum`	SVG/DXF/contour-DXF only: which world axis to project along (drop) — "z" is a top/plan view. "auto" (contour-dxf only) picks the axis the part is thinnest along, i.e. the sheet normal. one of "x", "y", "z", "auto" · default `"z"`
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`view` optional	`enum`	SVG/DXF only (CADSF-770): "wireframe" (default, unchanged) draws every tessellated-mesh edge with no occlusion test — see wireframe.js. "hlr" reuses ops/hlr.js's vector hidden-line-removal pipeline (CADSF-115): the body's real B-rep edges plus view-dependent silhouettes on curved faces (analytic where the surface is a plane/cylinder/cone/sphere/torus, tessellation-derived otherwise), occlusion-tested against the tessellated mesh via BVH raycast and split into visible/hidden runs — a drafting-grade view instead of a mesh dump: visible edges solid, hidden edges dashed on their own layer/group ("VISIBLE"/"HIDDEN" in DXF, id="visible"/id="hidden" groups in SVG). Reads "axis" for the camera direction the same three principal views wireframe mode offers ("auto" is not meaningful here and is treated as "z"); the response reports "visibleEdgeCount"/"hiddenEdgeCount" alongside the usual "edgeCount" (their sum). Refused for every format other than svg/dxf. one of "wireframe", "hlr"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `usda`

Argument	Type	Meaning & bounds
`bakeTransforms` optional	`boolean`	gltf/glb only: true bakes the mm→m scale and Z-up→Y-up rotation into the vertex buffers themselves; false (default) ships kernel-space coordinates under one root conversion node carrying that scale and rotation, so downstream tooling can still read kernel-space mm out of the buffers. default `false`
`creaseAngleDeg` optional	`number`	gltf/glb only (CADSF-753): crease gate in degrees for the tessellator's shading-normal pass (CADSB-472) — edges whose faces meet more smoothly than this are welded to one shared normal, sharper ones keep a hard crease (duplicated rim vertices). SceneReady spec §4 default is 30. This gate is what makes a runtime renderer shade the part correctly instead of flat faces as gradients (CADSB-514). > 0 · ≤ 180 · default `30`
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`materialsOverride` optional	`object[]`	gltf/glb only: glTF 2.0 material objects, passed through verbatim (kernel appearance→PBR mapping is CADSF-749; this is the manual override until then, and the override of it after). Pass ONE material (applied to every exported body) or exactly one per body in "of" resolution order — any other count is refused rather than guessed at. ≥ 1 items
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`upAxis` optional	`enum`	usda/usdz only (CADSF-777): which axis the STAGE declares as up — the USD metadatum admits exactly these two. "Z" (default for usda) is the kernel's own axis, so points are written verbatim with no rotation anywhere in the file. "Y" (default for usdz, because iOS AR Quick Look fixes Y as up) adds ONE root "xformOp:rotateX = -90" mapping (x,y,z)→(x,z,−y), or bakes it into the points with "bakeTransforms":true. Units are never carried by an xformOp: they are the stage's metersPerUnit (0.001, points in mm) unless "bakeTransforms" folds the scale in. one of "Z", "Y"
`uv` optional	`enum`	gltf/glb/usd: texture coordinates. "game" (default, SceneReady): TEXCOORD_0 metric (1 uv = 1 m or "uvScale" mm, tiling) + TEXCOORD_1 packed non-overlapping 0-1 atlas (bakes, decals). No images; materials carry extras.materialClass/paletteId. "normalized": per-face [0,1]². "world": fixed physical size. "none": no uvs. UVs duplicate seam/face-boundary vertices; report in asset.extras.conversion.uv. Format: docs/FORMATS.md. one of "game", "normalized", "world", "none" · default `"game"`
`uvAtlasPx` optional	`integer`	uv:"game": TEXCOORD_1 atlas size in texels (default 1024; 4-texel gutter). ≥ 64 · ≤ 16384
`uvScale` optional	`number`	gltf/glb/usd: mm of surface per uv unit — uv:"game" (default 1000, never snapped) or uv:"world" (default 10, snapped to whole tiles per revolution).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `usdz`

Argument	Type	Meaning & bounds
`bakeTransforms` optional	`boolean`	gltf/glb only: true bakes the mm→m scale and Z-up→Y-up rotation into the vertex buffers themselves; false (default) ships kernel-space coordinates under one root conversion node carrying that scale and rotation, so downstream tooling can still read kernel-space mm out of the buffers. default `false`
`creaseAngleDeg` optional	`number`	gltf/glb only (CADSF-753): crease gate in degrees for the tessellator's shading-normal pass (CADSB-472) — edges whose faces meet more smoothly than this are welded to one shared normal, sharper ones keep a hard crease (duplicated rim vertices). SceneReady spec §4 default is 30. This gate is what makes a runtime renderer shade the part correctly instead of flat faces as gradients (CADSB-514). > 0 · ≤ 180 · default `30`
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`materialsOverride` optional	`object[]`	gltf/glb only: glTF 2.0 material objects, passed through verbatim (kernel appearance→PBR mapping is CADSF-749; this is the manual override until then, and the override of it after). Pass ONE material (applied to every exported body) or exactly one per body in "of" resolution order — any other count is refused rather than guessed at. ≥ 1 items
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`upAxis` optional	`enum`	usda/usdz only (CADSF-777): which axis the STAGE declares as up — the USD metadatum admits exactly these two. "Z" (default for usda) is the kernel's own axis, so points are written verbatim with no rotation anywhere in the file. "Y" (default for usdz, because iOS AR Quick Look fixes Y as up) adds ONE root "xformOp:rotateX = -90" mapping (x,y,z)→(x,z,−y), or bakes it into the points with "bakeTransforms":true. Units are never carried by an xformOp: they are the stage's metersPerUnit (0.001, points in mm) unless "bakeTransforms" folds the scale in. one of "Z", "Y"
`uv` optional	`enum`	gltf/glb/usd: texture coordinates. "game" (default, SceneReady): TEXCOORD_0 metric (1 uv = 1 m or "uvScale" mm, tiling) + TEXCOORD_1 packed non-overlapping 0-1 atlas (bakes, decals). No images; materials carry extras.materialClass/paletteId. "normalized": per-face [0,1]². "world": fixed physical size. "none": no uvs. UVs duplicate seam/face-boundary vertices; report in asset.extras.conversion.uv. Format: docs/FORMATS.md. one of "game", "normalized", "world", "none" · default `"game"`
`uvAtlasPx` optional	`integer`	uv:"game": TEXCOORD_1 atlas size in texels (default 1024; 4-texel gutter). ≥ 64 · ≤ 16384
`uvScale` optional	`number`	gltf/glb/usd: mm of surface per uv unit — uv:"game" (default 1000, never snapped) or uv:"world" (default 10, snapped to whole tiles per revolution).

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `vdb`

Argument	Type	Meaning & bounds
`handle` optional	`string`	Reuse a mesh handle from a prior cad_tessellate_body call instead of re-tessellating (stl/svg/dxf/3mf/3mf-bambu only).
`healGeometry` optional	`boolean`	Attempt to heal small topology defects (gaps, sliver faces) before tessellating. default `false`
`maxEdgeLength` optional	`number`	Split any triangle edge longer than this many mm, repeatedly, until every edge is under it (or a generous pass cap is hit). New vertices sit at the exact chord midpoint; their normal is read from the face's own analytic surface where the edge borders exactly one such face, otherwise it is the average of the adjoining facets' normals. Face ids and watertightness are preserved. Omit for the tessellator's own chordal resolution only. > 0
`maxTriangles` optional	`integer`	Triangle budget: the tessellator adapts its resolution (subdivision search, then chord-tolerance coarsening) to come in at or under this count, and the response's "lod" field reports what was achieved — including an explicit shortfall flag when even the coarsest achievable mesh exceeds the budget. Omit to let tolerance (or the kernel default) drive resolution instead. > 0
`minTrianglesPerFace` optional	`integer`	Force every face with fewer triangles than this up to it, via the same conforming split as "maxEdgeLength" (and combinable with it). Useful for a large flat face a chordal tolerance leaves as 2 triangles but a field sampler needs many sample points across. > 0
`sizing` optional	`object`	Size field (mm): global max/min, N elements across thin gaps, and "refine here to h" regions. Replaces maxTriangles as the budget control.
`sizing.angularCapDeg`	`number`	Normal-deviation cap on curved faces, degrees. 15-20; default 18. Stops hexagon fillets. > 0 · ≤ 90
`sizing.elementsAcrossGap`	`integer`	Elements to fit across a thin wall or gap the mesh finds for itself. Default 3. ≥ 1
`sizing.featureEdges`	`boolean`	Set false to skip the sharp-edge source.
`sizing.growthRatio`	`number`	Max size ratio between neighbouring cells (gradation). 1.2-1.3; default 1.25. ≥ 1 · ≤ 2
`sizing.hMax`	`number`	Global max element size in mm. No triangle edge ends up longer than this. > 0
`sizing.hMin`	`number`	HARD floor in mm. No source can drive the size below it; this is what bounds the work. > 0
`sizing.maxDepth`	`integer`	Octree depth cap. Bounds memory and time absolutely. Default 8. ≥ 1 · ≤ 12
`sizing.maxTriangles`	`integer`	Per-body triangle budget for the refinement. hMin bounds the SIZE; this bounds the COUNT. > 0
`sizing.proximity`	`boolean`	Set false to skip the gap/thin-wall source.
`sizing.regions`	`object[]`	Refine-here regions: a box, sphere or cylinder plus the size h to use inside it. ≤ 32 items
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`voxelSize` optional	`number`	picogk_stl / vdb only (CADSF-101045): the PicoGK voxel size in mm the file is prepared for. Sets the default chord tolerance (voxelSize/4) and, for vdb, the grid pitch. > 0 · ≤ 100

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `vehicle`

Argument	Type	Meaning & bounds
`tolerance` optional	`number`	Chord tolerance in mm: the max allowed deviation between the tessellated triangles and the true surface. Smaller = finer mesh, more triangles, slower. Omit for the kernel default — except on a SWEPT or LOFTED body, where the default can exceed the host's call timeout: pass 1 mm or more (and edges:false on the mesh payload). > 0
`vehicle` optional	`object`	vehicle only (CADSF-100529): {class: aircraft\|ship\|ground\|rocket\|lander\|object, preset, id, name, density, parts:{<body>:{role, mass, density, joint, kinematic}}}.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `x_b`

Argument	Type	Meaning & bounds
`units` optional	`enum`	x_t/x_b (CADSB-818): the unit the transmit's own numbers are written in, "m" or "mm". Default "m" — Parasolid's convention [S §4.2.1], the one every vendor transmit in this repo's corpus uses, so the file opens at the right size in SolidWorks/NX. Pass "mm" only to reproduce the pre-CADSB-818 byte shape (kernel mm written unscaled). dxf (CADSF-100617, wireframe and "view":"hlr"): the unit the drawing is written in — every coordinate is CONVERTED from the kernel's millimetres and the header declares it ($INSUNITS, with $MEASUREMENT). Default "mm", byte-identical coordinates to before; the document's declared import unit is not applied by itself, pass it here to get that unit. cm/in/ft/um are dxf only; contour-dxf and flat-dxf are always millimetres, and no other format takes a unit. one of "m", "mm", "cm", "in", "ft", "um"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Format `x_t`

Argument	Type	Meaning & bounds
`colors` optional	`object`	US spelling of "colours" (same map) ≥ 1 keys
`colours` optional	`object`	step / ap242-xml / x_t (CADSF-2886): body colours, { "<body ref \| op id \| part name>": "#RRGGBB" \| [r,g,b] }. Each named body is written with one STYLED_ITEM/COLOUR_RGB (STEP) or SDL/TYSA_COLOUR (x_t), and the colour stays on the document for later exports. Colours already on the document (an imported file's, earlier calls') are always written, with or without this. A key naming no body is refused COLOUR_NO_BODY. ≥ 1 keys
`units` optional	`enum`	x_t/x_b (CADSB-818): the unit the transmit's own numbers are written in, "m" or "mm". Default "m" — Parasolid's convention [S §4.2.1], the one every vendor transmit in this repo's corpus uses, so the file opens at the right size in SolidWorks/NX. Pass "mm" only to reproduce the pre-CADSB-818 byte shape (kernel mm written unscaled). dxf (CADSF-100617, wireframe and "view":"hlr"): the unit the drawing is written in — every coordinate is CONVERTED from the kernel's millimetres and the header declares it ($INSUNITS, with $MEASUREMENT). Default "mm", byte-identical coordinates to before; the document's declared import unit is not applied by itself, pass it here to get that unit. cm/in/ft/um are dxf only; contour-dxf and flat-dxf are always millimetres, and no other format takes a unit. one of "m", "mm", "cm", "in", "ft", "um"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bytes` required	`integer`	—
`format` required	`enum`	— one of "stl", "step", "svg", "dxf", "contour-dxf", "flat-dxf", "pdf", "prc", "gltf", "glb", "usda", "usdz", "x_t", "x_b", "3mf", "3mf-bambu", "3mf-project", "3mf-beamlattice", "sat", "ap242-xml", "ifc", "picogk_stl", "vdb", "ply", "vehicle", "fcstd", "qif"
`path` required	`string`	—
`area` optional	`number`	—
`assembly` optional	`object`	—
`attachments` optional	`object[]`	—
`axis` optional	`string`	—
`bambuAssembly` optional	`object`	—
`beamLattice` optional	`object`	—
`beamLattice.balls`	`integer`	—
`beamLattice.beamSets`	`integer`	—
`beamLattice.beams`	`integer`	—
`beamLattice.cap`	`enum`	— one of "sphere", "hemisphere", "butt"
`beamLattice.clippingBody`	`string`	—
`beamLattice.clippingMode`	`enum`	— one of "none", "inside", "outside"
`beamLattice.dropped`	`object`	—
`beamLattice.minLength`	`number`	—
`beamLattice.radius`	`number`	—
`beamLattice.strutSource`	`string`	—
`beamLattice.struts`	`integer`	—
`beamLattice.unit`	`string`	—
`bed` optional	`object[]`	—
`bendLines` optional	`integer`	—
`bendSchedule` optional	`object[]`	—
`binPath` optional	`string`	—
`blank` optional	`object`	—
`blank.area`	`number`	—
`blank.boundingArea`	`number`	—
`blank.length`	`number`	—
`blank.notchArea`	`number`	—
`blank.thickness`	`number`	—
`blank.width`	`number`	—
`buildObjects` optional	`integer`	—
`census` optional	`object`	—
`compression` optional	`object`	—
`compression.extensions`	`string[]`	—
`compression.instance`	`boolean`	—
`compression.instancedNodes`	`integer`	—
`compression.instances`	`integer`	—
`compression.meshes`	`integer`	—
`compression.nodesAfter`	`integer`	—
`compression.nodesBefore`	`integer`	—
`compression.quantize`	`boolean`	—
`compression.quantizedMeshes`	`integer`	—
`confidence` optional	`enum`	— one of "confident", "candidate"
`contours` optional	`integer`	—
`developedLength` optional	`number`	—
`developedLengths` optional	`object`	—
`developedLengths.x`	`number`	—
`developedLengths.y`	`number`	—
`edgeCount` optional	`integer`	—
`entities` optional	`object`	—
`entities.arc`	`integer`	—
`entities.circle`	`integer`	—
`entities.line`	`integer`	—
`entities.polyline`	`integer`	—
`entities.text`	`integer`	—
`entities.total`	`integer`	—
`entries` optional	`string[]`	—
`envelope` optional	`object`	—
`envelope.bodies`	`integer`	—
`envelope.dropped`	`integer`	—
`envelope.droppedNames`	`string[]`	—
`envelope.kept`	`integer`	—
`envelope.resolution`	`integer`	—
`envelope.views`	`integer`	—
`exportProfile` optional	`object`	—
`extraction` optional	`object \| string`	—
`faceId` optional	`string`	—
`fcstd` optional	`object`	—
`fieldBody` optional	`string`	—
`filaments` optional	`object[]`	—
`geometricLength` optional	`number`	—
`hiddenEdgeCount` optional	`integer`	—
`hint` optional	`string`	—
`hybrid` optional	`object`	—
`ifc` optional	`object`	—
`instances` optional	`integer`	—
`layers` optional	`object`	—
`layers.bendDown`	`string`	—
`layers.bendUp`	`string`	—
`layers.outline`	`string`	—
`layers.tangent`	`string`	—
`layers.text`	`string`	—
`lod` optional	`object`	—
`lod.levelCount`	`integer`	—
`lod.levels`	`object[]`	—
`lod.mode`	`enum`	— one of "single", "files"
`lod.monotonic`	`boolean`	—
`lod.extension`	`string`	—
`lod.screenCoverage`	`number[]`	—
`lod.totalBytes`	`integer`	—
`markups` optional	`integer`	—
`materials` optional	`object`	—
`notches` optional	`object[]`	—
`objects` optional	`integer`	—
`openWith` optional	`string`	—
`partPaths` optional	`string[]`	—
`parts` optional	`integer`	—
`pdfa` optional	`object`	—
`pdfa.conformance`	`string`	—
`pdfa.label`	`string`	—
`pdfa.level`	`enum`	— one of "3b", "4e"
`pdfa.part`	`integer`	—
`pdfa.permits3D`	`boolean`	—
`picogk` optional	`object`	—
`plates` optional	`integer`	—
`pmiFrom` optional	`string`	—
`primeTower` optional	`object`	—
`products` optional	`integer`	—
`profile` optional	`string`	—
`qif` optional	`object`	—
`resolution` optional	`enum`	— one of "full", "print"
`rotationBaked` optional	`boolean`	—
`schema` optional	`object`	—
`schema.dropped`	`any[]`	—
`schema.expanded`	`any[]`	—
`schema.fileSchema`	`string \| null`	—
`schema.id`	`string \| null`	—
`schema.warnings`	`string[]`	—
`semanticPmi` optional	`integer`	—
`slots` optional	`integer[]`	—
`source` optional	`enum`	— one of "mesh", "implicit", "field"
`stepFrom` optional	`string`	—
`streamed` optional	`boolean`	—
`supports` optional	`object`	—
`tessellated` optional	`object`	—
`triangles` optional	`integer`	—
`uncompressedBytes` optional	`integer`	—
`units` optional	`object`	—
`units.applied`	`enum`	— one of "m", "mm", "cm", "in", "ft", "um"
`units.scale`	`number`	—
`usd` optional	`object`	—
`usd.meshes`	`integer`	—
`usd.metersPerUnit`	`number`	—
`usd.upAxis`	`enum`	— one of "Z", "Y"
`usd.verified`	`boolean`	—
`usd.alignment`	`integer`	—
`usd.entries`	`integer`	—
`usd.layerName`	`string`	—
`usd.materials`	`integer`	—
`usd.pointUnits`	`enum`	— one of "mm", "m"
`usd.points`	`integer`	—
`uv` optional	`object`	—
`uv.atlasPx`	`integer`	—
`uv.boxProjectedTriangles`	`integer`	—
`uv.charts`	`integer`	—
`uv.faceSplitVertices`	`integer`	—
`uv.gutterPx`	`number`	—
`uv.mode`	`enum`	— one of "game", "normalized", "world"
`uv.seamVertices`	`integer`	—
`uv.tangents`	`boolean`	—
`uv.tessellatedVertices`	`integer`	—
`uv.texcoord0`	`string`	—
`uv.texcoord1`	`string`	—
`uv.uvScaleMm`	`number`	—
`uv.vertices`	`integer`	—
`validation` optional	`object`	—
`vehicle` optional	`object`	—
`vertices` optional	`integer`	—
`view` optional	`enum`	— one of "wireframe", "hlr"
`views` optional	`integer`	—
`visibleEdgeCount` optional	`integer`	—
`warnings` optional	`string[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_drawing` write Make the drawings

Make the drawings: one call turns a part or assembly (a session body, or a customer STEP via "file") into a shop-ready drawing set — planned views, sheet size and scale, a shop profile's title block and general tolerance block, the default GD&T scheme and its table, hole notes, an assembly parts list — written as PD…

Full description

F… Call cad_help({tool:"cad_drawing"}) for the rest.

Argument	Type	Meaning & bounds
`allowLintErrors` optional	`boolean`	Write a sheet that fails its tolerance lint… default `false`
`assembly` optional	`boolean`	Draw the bodies as one assembly…
`bom` optional	`boolean`	Assembly parts list. default `true`
`dimensions` optional	`boolean`	— default `true`
`docMeta` optional	`object`	Title block: title, partNumber, revision, mater…
`document` optional	`string`	Document handle (default: the active one).
`fasteners` optional	`object[]`	Hardware per hole class…
`file` optional	`string`	A STEP file to draw instead of session bodies…
`formats` optional	`enum[]`	Default all three; the PDF is one page per sheet. ≥ 1 items
`gdt` optional	`enum`	auto: the default datum/position/profile scheme… one of "auto", "off" · default `"auto"`
`gdtStyle` optional	`enum`	Default per process: lean for castings and cut… one of "full", "lean"
`holes` optional	`boolean`	Hole notes (with gdt auto they are always on). default `true`
`maxDimensions` optional	`integer`	— ≥ 1 · ≤ 200 · default `60`
`name` optional	`string`	File stem; default partNumber.
`of` optional	`string \| array`	Body handle(s) to draw; default every live body…
`outDir` optional	`string`	Relative paths resolve under the configured out…
`process` optional	`string`	Sizes the profile zone: cnc, laser, waterjet, c… default `"cnc"`
`projection` optional	`enum`	— one of "third", "first" · default `"third"`
`scale` optional	`string`	"auto" or "n:m". default `"auto"`
`shopProfile` optional	`string`	asme-mm \| asme-in \| iso-2768-m \| a saved profil…
`size` optional	`string`	Force a sheet size (A4..A0, ANSI_A..ANSI_E); de…
`standard` optional	`enum`	Sheet series (ANSI A-E / ISO A4-A0) and title-b… one of "asme", "iso" · default `"asme"`
`views` optional	`string[]`	Keep only these planned views…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Quoting, evaluation & sharing · 12

What happens after the geometry is right: priced quote payloads and submissions, evaluation packets and reports, shareable results, and showcase-contest entries.

`cad_quote_payload` read Quote feature vector (process, material, thickness, finish)

The complete instant-quote FEATURE VECTOR for a solid already built in the active session, in one call.

Full description

Call cad_help({tool:"cad_quote_payload"}) for the rest.

Argument	Type	Meaning & bounds
`process` required	`enum`	The manufacturing route being quoted. one of "laser", "waterjet", "router", "bend", "mill", "lpbf"
`solid` required	`string`	id or "<id>#<n>"
`dfm` optional	`boolean`	Run the per-process DFM rule pack.
`dfmParams` optional	`object`	Parameters handed to the DFM rule pack, e.g. {"…
`finish` optional	`string[]`	Secondary services requested, as flags on the p…
`material` optional	`string`	Stock material.
`partId` optional	`string`	Caller-side part identifier echoed into the pay…
`partName` optional	`string`	Human-readable part name echoed into the payload.
`quantity` optional	`integer`	Order quantity, echoed into the payload and int… ≥ 1
`revision` optional	`string`	Revision string echoed into the payload.
`thickness` optional	`number`	Stock thickness in mm. > 0
`thicknessIn` optional	`number`	Stock thickness in inches (25.4 mm/in). > 0
`thinWallThreshold` optional	`number`	mm — wall samples under this are counted in g… > 0
`weld` optional	`object`	A cad_weld_schedule result to fold in.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_weld_schedule` read Weld schedule and arc minutes for a STEP assembly

WELD LABOUR measured off the geometry.

Full description

Every contact in a STEP assembly is classified into a joint — fillet on a tee, corner or lap, groove on a butt, or a circumferential fillet at a coaxial engagement — with path length, AWS D1.1 minimum leg for the thinner member, weld position and a torch-access check. Call cad_help({tool:"cad_weld_schedule"}) for the rest.

Argument	Type	Meaning & bounds
`file` required	`string`	STEP assembly or multi-body part file. length ≥ 1
`accessClearanceMm` optional	`number`	Torch corridor depth, mm. Default 25. > 0
`bothSidesTee` optional	`boolean`	Weld tees both sides. Default true.
`depositionRateKgH` optional	`number`	Deposition rate override, kg/arc-hour. > 0
`fitUpMinutesPerJoint` optional	`number`	Fit-up and tack minutes per joint. Default 4. ≥ 0
`jointsOnly` optional	`boolean`	Return totals and joints, drop the option echo.
`legMm` optional	`number`	Fillet leg override, mm. > 0
`maxClearance` optional	`number`	Contact reporting window, mm. Default 1. > 0
`maxJoints` optional	`integer`	Cap on joints returned. Default 50. ≥ 1 · ≤ 200
`minArea` optional	`number`	Smallest overlap worth welding, mm^2. ≥ 0
`operatorFactor` optional	`number`	Arc-on share of clock time. Default 0.35. > 0 · ≤ 1
`process` optional	`enum`	Welding process. Default gmaw. one of "gmaw", "fcaw", "smaw", "gtaw"
`thickness` optional	`object`	Member thickness overrides, mm, by body name.
`tol` optional	`number`	Coincidence tolerance, mm. Default 0.001. > 0
`units` optional	`string`	Length-unit override: mm, cm, m, in, ft.
`up` optional	`number[]`	Build orientation up vector. Default 0,0,1. exactly 3 items

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_quote_submit` write Fabricator quote (DFM gate → package → submit)

Package a body this session built as an instant-quote submission for one fabrication route.

Full description

THE FIRST CALL SENDS NOTHING: it returns the verdict plus a "confirm" digest; call again with confirm:"<that digest>" to submit. Call cad_help({tool:"cad_quote_submit"}) for the rest.

Argument	Type	Meaning & bounds
`route` required	`enum`	The fabrication route to quote on. one of "scs_laser", "scs_waterjet", "scs_router", "scs_bend", "scs_mill", "osh_laser", "osh_bend", "osh_tube", "fictiv_mill", "fictiv_im", "fictiv_print"
`allowUnapproved` optional	`boolean`	Submit despite a DFM-gate block.
`confirm` optional	`string`	Preview digest; without it nothing is sent.
`cutterDiameter` optional	`number`	Milling: end-mill Ø in mm, default 6.
`encoding` optional	`enum`	Wire shape, default multipart. one of "multipart", "json"
`endpoint` optional	`string`	Endpoint override for this call.
`file` optional	`string`	A file you already exported.
`material` optional	`string`	Material, as the fabricator names it.
`notes` optional	`string`	Free-text note carried with the submission.
`partName` optional	`string`	Name for the part on the quote.
`quantity` optional	`integer`	How many parts. Default 1. ≥ 1
`services` optional	`enum[]`	Post-process flags, never geometry.
`solid` optional	`string`	A body built in this session.
`thickness` optional	`number`	Material thickness in MILLIMETRES.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_evaluate` write Run the evaluation battery on customer geometry

Import one or more STEP files and run a battery of kernel operations against every body they contain.

Full description

Call cad_help({tool:"cad_evaluate"}) for the rest.

Argument	Type	Meaning & bounds
`files` required	`string[]`	STEP file paths to evaluate — absolute, or re… ≥ 1 items · ≤ 200 items
`consent` optional	`object`	Consent to receive an IP-free evaluation report…
`consent.contact`	`object`	—
`consent.sendReport`	`true`	Must be exactly true.
`criteria` optional	`object[]`	What would make this kernel adequate FOR YOU… ≥ 1 items · ≤ 50 items
`maxBodiesPerFile` optional	`integer`	Per-file cap on how many bodies get the full ba… ≥ 1
`maxProbeEdges` optional	`integer`	How many convex edges the fillet probe selects… ≥ 1
`outputDir` optional	`string`	Directory the evaluation-run JSON is written to.
`persist` optional	`boolean`	Write the run document to disk.
`probes` optional	`boolean`	Run the MUTATING half of the battery…
`runId` optional	`string`	Override the generated run id…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_eval_packet` write Extract an IP-safe failure packet from an evaluation run

Turn the failures in a cad_evaluate run into a shareable packet that does NOT contain the customer's model.

Full description

Call cad_help({tool:"cad_eval_packet"}) for the rest.

Argument	Type	Meaning & bounds
`archive` optional	`boolean`	Also write the single-file .tar.gz archive…
`disclosure` optional	`object \| string`	How much is disclosed per issue (default "L1").
`issueIds` optional	`string[]`	The issues to extract, by issues[].id in the ru… ≤ 200 items
`keepBodyRegions` optional	`boolean`	Keep bodies[].boundingRegion in the redacted ru…
`keepOperationDetail` optional	`boolean`	Keep operations[].detail in the redacted run…
`maxIssueVolumeFraction` optional	`number`	Per-issue cap on disclosed volume, as a fractio… > 0 · ≤ 1
`maxIssues` optional	`integer`	How many issues to extract when issueIds is omi… ≥ 1 · ≤ 200
`maxReproducers` optional	`integer`	How many distinct synthetic reproducers this pa… ≥ 0 · ≤ 20
`maxTotalVolumeFraction` optional	`number`	Cap on the WHOLE packet's disclosed volume, sam… > 0 · ≤ 1
`minBoxMm` optional	`number`	Minimum crop-box side, in mm (default 2). > 0
`minPadMm` optional	`number`	Floor on the padding, in mm (default 0.5). ≥ 0
`onVolumeCapExceeded` optional	`enum`	What to do when a cap is exceeded… one of "refuse", "omit"
`outputDir` optional	`string`	Directory the packet is written to.
`overwrite` optional	`boolean`	Replace an existing packet for this run…
`paddingFraction` optional	`number`	Crop padding as a fraction of the failure regio… ≥ 0 · ≤ 2
`runDir` optional	`string`	Directory runId is resolved against.
`runFile` optional	`string`	Path to the evaluation-run JSON cad_evaluate wr… length ≥ 1
`runId` optional	`string`	The run id, resolved to <runDir>/<runId>.json… length ≥ 1

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`archive` optional	`string \| null`	—
`archiveBytes` optional	`integer \| null`	—
`counts` optional	`object`	—
`manifest` optional	`object`	The redaction manifest…
`packetDir` optional	`string`	—
`summary` optional	`string`	The human-readable preview — identical to the…

`cad_eval_report` write Evaluation scorecard report

Turn a persisted cad_evaluate run into one self-contained, printable HTML scorecard for the customer whose data was evaluated: headline verdict, pass/fail by operation class, failure modes rolled up by cause, findings localised by bounding box, and marginal timings (the STEP-import replay carried by isolated probes …

Full description

is subtracted). Call cad_help({tool:"cad_eval_report"}) for the rest.

Argument	Type	Meaning & bounds
`run` required	`string`	The evaluation run to report on: either the run… length ≥ 1
`datasetLabels` optional	`string[]`	Names for the evaluated files, by position: dat… ≤ 200 items
`gapCloseNarrative` optional	`string`	Your own account, as the agent that ran this ev… length ≤ 8000
`incumbent` optional	`object`	Your results for the same battery on the same d…
`incumbentFile` optional	`string`	Path to a JSON file holding the same document a…
`label` optional	`string`	Your own title for this evaluation, printed as… length ≤ 200
`persist` optional	`boolean`	Write the report next to the run as "<runId>.re…
`preparedFor` optional	`string`	Who the report is for — a company, a team or… length ≤ 200
`runsDir` optional	`string`	Directory to look for a bare runId in.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_eval_share` write Review, consent to and share an evaluation failure packet

Share the IP-safe failure packet for a cad_evaluate run with NativeCAD, and get a link to book an evaluation call — in two explicit steps.

Full description

Call cad_help({tool:"cad_eval_share"}) for the rest.

Argument	Type	Meaning & bounds
`runId` required	`string`	The evaluation run to share the failure packet… length 1–200
`bookingUrl` optional	`string`	Base URL of the booking page for the evaluation…
`bundleDir` optional	`string`	Where the ready-to-send bundle is written.
`confirm` optional	`boolean`	Actually share.
`consentToken` optional	`string`	The token returned by the preview call.
`intakeUrl` optional	`string`	Submit to this endpoint instead of the default…
`note` optional	`string`	Your own covering note to the vendor — what y… length ≤ 4000
`offline` optional	`boolean`	Never use the network: write the ready-to-send…
`requesterEmail` optional	`string`	Your reply address, so the vendor can answer. length ≤ 320
`requesterName` optional	`string`	Who is sending it — a person or a team. length ≤ 200
`resend` optional	`boolean`	Allow a consent token that has already been use…
`runsDir` optional	`string`	Directory holding the run, its packet, its repo…
`updateReport` optional	`boolean`	Fill the "Share the findings" section of this r…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`booking` optional	`object`	—
`configuration` optional	`object`	—
`consent` optional	`object`	—
`delivery` optional	`object`	—
`disclosure` optional	`object`	—
`evaluation` optional	`object \| null`	The terms the report that comes back is owed ag…
`files` optional	`any[]`	Every file inside the packet, with its size and…
`history` optional	`object`	—
`instructions` optional	`string[]`	—
`nextCall` optional	`object`	—
`notice` optional	`string`	—
`packet` optional	`object`	—
`preview` optional	`string \| null`	The packet's own README.txt, verbatim.
`record` optional	`object`	—
`report` optional	`object`	—
`runId` optional	`string`	—
`runSummary` optional	`object`	—
`shared` optional	`boolean`	—
`stage` optional	`string`	"preview" (nothing sent) or "submitted".
`verification` optional	`object`	—
`warnings` optional	`string[]`	—

`cad_gap_registry` read Capability-gap register and issue classifier

Register of known capability gaps — things this kernel cannot do, each with operation class, failure mode, evidence, status, ticket and day estimate.

Full description

action:"list" returns it (filter by status/opClass/failureMode/gapId) with an open-days roll-up. Call cad_help({tool:"cad_gap_registry"}) for the rest.

Argument	Type	Meaning & bounds
`action` optional	`enum`	list — read the register (optionally filtered). one of "list", "match" · default `"list"`
`failureMode` optional	`enum`	list: only gaps that fail this way. one of "refused", "not-watertight", "wrong-volume", "divergent", "unchecked-failure", "timeout", "over-budget"
`gapId` optional	`string`	list: one gap by id.
`issues` optional	`object[]`	match: the issues to classify… ≥ 1 items · ≤ 500 items
`opClass` optional	`enum`	list: only gaps filed under this operation class. one of "import", "stitch", "validation", "tessellation", "massProperties", "boolean", "blend", "shell", "hole", "pattern", "loft", "rib", "draft", "topology", "export"
`status` optional	`enum`	list: only gaps in this state. one of "open", "in-progress", "closed"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_cert` write Certification evidence plan and packet

Certification-evidence engine in one tool.

Full description

action:"plan" turns a context of use + model influence + decision consequence into a V&V 40-style risk level and the evidence it needs: requiredEvidence (credibility goals), verificationCases (ids from the verification suite), analyses, and gaps (e.g. requirements with no linked analysis). Call cad_help({tool:"cad_cert"}) for the rest.

Argument	Type	Meaning & bounds
`action` optional	`enum`	plan - risk and evidence needed. one of "plan", "run", "verify", "packet"
`bodyId` optional	`string`	plan: the body the plan is for…
`consequence` optional	`enum`	plan: harm if the decision is wrong. one of "low", "medium", "high"
`contextOfUse` optional	`string`	plan: the decision the analysis supports, in a… length ≥ 1
`evidenceDir` optional	`string`	packet: directory holding evidence under manife…
`influence` optional	`enum`	plan: how much the model result drives the deci… one of "low", "medium", "high"
`outDir` optional	`string`	packet: directory the packet is written to.
`physics` optional	`string`	plan: restrict verification cases to one physic…
`requirements` optional	`object[]`	plan: [{id, text?, source?, acceptance:{quantit… ≤ 200 items
`sign` optional	`boolean`	packet: sign with the ed25519 key in CADSOLVER_… default `true`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_spec_configure` read Spec-driven part configurator (options → part number → build plan)

Configure a part the way a components catalogue does: a family plus options (or one part number) in; resolved parameters, a canonical part number, a kernel build plan and the quote route/material out.

Full description

These are NativeCAD's own families and codes, not any manufacturer's catalogue. Call cad_help({tool:"cad_spec_configure"}) for the rest.

Argument	Type	Meaning & bounds
`code` optional	`string`	A part number to decode.
`family` optional	`enum`	The part family to configure. one of "plate", "spacer", "shaft"
`options` optional	`object`	Option values by key.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_configurator` write Modular-product configurator (validate / enumerate / nearest fix / build)

Check a modular product configuration against its product family's compatibility rules, and build it.

Full description

Call cad_help({tool:"cad_configurator"}) for the rest.

Argument	Type	Meaning & bounds
`action` required	`enum`	What to do with the configuration. one of "validate", "enumerate", "nearestFix", "build"
`config` optional	`object`	Parameter values by name.
`document` optional	`string`	build: session document to build into.
`family` optional	`object`	The product family, inline.
`familyPath` optional	`string`	Path to a product-family JSON file.
`fix` optional	`object`	enumerate: values held fixed.
`limit` optional	`integer`	enumerate: most variants returned. ≥ 1 · ≤ 500
`lock` optional	`string[]`	nearestFix: parameters it may not change.
`modules` optional	`string[]`	Optional modules selected.
`required` optional	`string[]`	Interfaces that must mate.
`stepPath` optional	`string`	build: also write the assembly as STEP here…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_contest` write Enter a NativeCAD showcase contest

Enter a NativeCAD showcase contest with the default package, no licence key.

Full description

Get a ticket on the contest page ("contests" lists them). Call cad_help({tool:"cad_contest"}) for the rest.

Argument	Type	Meaning & bounds
`action` optional	`enum`	contests: list open contests; start: check a ti… one of "contests", "start", "status", "submit", "end" · default `"status"`
`agree` optional	`boolean`	"submit": must be true — the entrant's consen…
`animations` optional	`object[]`	"submit": animation clips, as cad_export_body t… ≥ 1 items
`builder` optional	`string`	"submit": public display name… length ≤ 60
`contest` optional	`string`	contests: one slug to describe in full. pattern `^[a-z0-9][a-z0-9-]{2,39}$`
`description` optional	`string`	"submit": what it is (≤1200 chars). length ≤ 1200
`document` optional	`string`	"submit": the document to read, as cad_export_b…
`howItMoves` optional	`string`	"submit": what the animation does (≤400 chars). length ≤ 400
`material` optional	`object \| string`	"submit": stock name or PBR material for bare b…
`of` optional	`string`	"submit": the body to enter; omit for the whole…
`replaces` optional	`string`	"submit": one of your own entry ids to update i… pattern `^[a-z2-9]{14}$`
`tags` optional	`string[]`	"submit": up to 5 tags, each ≤24 chars of [a-… ≤ 5 items
`ticket` optional	`string`	"start": the NCC1.… ticket e-mailed from the… length ≤ 200
`title` optional	`string`	"submit": the entry's title (3-80 chars). length 3–80

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Printing (Bambu Lab X1 Carbon) · 10

The additive path: slice a part with the user's own Bambu Studio, send the .gcode.3mf to an X1 Carbon over the LAN (or hand a human a Bambu Connect link), and watch the job. docs/PRINT_PIPELINE.md carries the whole pipeline, including what LAN-only + Developer Mode disconnects.

`cad_print_prep` write CAD to X1C, in one call

ONE CALL from a body you built to a file a Bambu Lab X1 Carbon prints: the fdm_x1c DFM pack, the build-orientation search, a Bambu 3MF carrying that orientation and the filament slots, a slice, and - with "send" - the print.

Full description

Call cad_help({tool:"cad_print_prep"}) for the rest.

Argument	Type	Meaning & bounds
`allowCosmeticDown` optional	`boolean`	Allow lettering/colour face…
`allowNozzleChange` optional	`boolean`	Dual-nozzle Bambu: allow on…
`amsUnits` optional	`object[]`	Bambu: the multi-material u… ≤ 16 items
`bodies` optional	`string[]`	Several handles on one plate. ≥ 1 items · ≤ 16 items
`body` optional	`string`	Body handle to print… length ≥ 1
`colours` optional	`string[]`	One "#RRGGBB" per body. ≥ 1 items · ≤ 16 items
`counts` optional	`integer[]`	Copies per body; nested by… ≥ 1 items · ≤ 16 items
`document` optional	`string`	Document to read the bodies…
`fallback` optional	`enum`	No slicer: "estimate"… one of "estimate", "refuse"
`force` optional	`boolean`	Carry on past a failing DFM…
`importCheck` optional	`boolean`	false skips the Bambu Studi…
`material` optional	`enum`	Filament for every body. one of "PLA", "PETG", "ABS", "TPU"
`materials` optional	`enum[]`	One per body, in the order… ≥ 1 items · ≤ 16 items
`maxSwitches` optional	`integer`	Filament-switch budget… ≥ 0
`nest` optional	`boolean`	Several bodies or counts go…
`nozzle` optional	`enum`	Fitted nozzle, mm. one of 0.2, 0.4, 0.6, 0.8
`nozzleBySlot` optional	`object`	Dual-nozzle Bambu…
`orient` optional	`enum`	"auto" (default) searches a… one of "auto", "keep"
`out` optional	`string`	Where to write the .3mf.
`params` optional	`object`	fdm_x1c pack params for the…
`printer` optional	`string`	The machine: any data/print… length ≥ 1
`process` optional	`string`	Stock process preset…
`send` optional	`object`	Send the sliced file over t…
`send.accessCode`	`string`	LAN access code, from the p…
`send.ip`	`string`	The printer's LAN IP.
`send.serial`	`string`	Serial number.
`supports` optional	`enum`	"auto" (default) generates… one of "auto", "none", "painted-later"
`timeoutSec` optional	`integer`	Wall-clock budget for the s… ≥ 10 · ≤ 7200

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`colourChanges` required	`object`	—
`colourChanges.count`	`integer`	—
`colourChanges.flushG`	`number`	—
`colourChanges.basis`	`string`	—
`colourChanges.budget`	`integer`	—
`colourChanges.layerHeight`	`number`	—
`colourChanges.mixed`	`object[]`	—
`colourChanges.predicted`	`integer`	—
`colourChanges.purgeMm3`	`number`	—
`colourChanges.remedy`	`string[]`	—
`colourChanges.slots`	`integer`	—
`dfm` required	`object`	—
`dfm.pass`	`boolean`	—
`dfm.verdicts`	`object[]`	—
`dfm.blockedBy`	`string[]`	—
`dfm.bodies`	`object[]`	—
`file` required	`string \| null`	—
`ms` required	`integer`	—
`ok` required	`boolean`	—
`orientation` required	`object`	—
`orientation.chosen`	`string \| null`	—
`orientation.supportAreaMm2`	`number \| null`	—
`orientation.applied`	`boolean`	—
`orientation.bedContactMm2`	`number \| null`	—
`orientation.buildDirection`	`array \| null`	— exactly 3 items
`orientation.candidates`	`integer`	—
`orientation.fits`	`boolean \| null`	—
`orientation.fitsExclusion`	`boolean \| null`	—
`orientation.footprintMm2`	`number \| null`	—
`orientation.heightMm`	`number \| null`	—
`orientation.source`	`string`	—
`orientation.supportNeedMm2`	`number \| null`	—
`orientation.supportVolumeEstMm3`	`number \| null`	—
`orientation.supports`	`object \| null`	CADSF-2164: "supports neede…
`orientation.transform`	`array \| null`	— exactly 16 items
`printer` required	`string`	—
`stage` required	`enum`	— one of "dfm", "orientation", "export", "import_check", "slice", "print"
`bodies` optional	`string[]`	—
`bytes` optional	`integer`	—
`estimate` optional	`object`	—
`estimate.band`	`object`	—
`family` optional	`object`	Bambu beyond the X1C…
`filaments` optional	`object[]`	—
`forced` optional	`boolean`	—
`importCheck` optional	`object`	CADSF-2283: does the file l…
`lettering` optional	`object[]`	CADSF-2284: per body, how m…
`nest` optional	`object`	—
`nozzle` optional	`number`	—
`preview` optional	`object`	—
`preview.autoOrientFlips`	`boolean \| null`	—
`preview.bytes`	`integer`	—
`preview.caption`	`string`	—
`preview.handoff`	`string[]`	—
`preview.height`	`integer`	—
`preview.lettering`	`object`	—
`preview.orientation`	`string \| null`	—
`preview.path`	`string`	—
`preview.sizeMm`	`number[]`	—
`preview.tintedShare`	`number`	—
`preview.verdict`	`string`	—
`preview.width`	`integer`	—
`print` optional	`object`	—
`print.connectUrl`	`string \| null`	—
`print.reason`	`string \| null`	—
`print.started`	`boolean \| null`	—
`print.taskId`	`string \| null`	—
`process` optional	`string \| null`	—
`slice` optional	`object`	—
`slice.method`	`enum`	— one of "slice", "estimate"
`slice.filaments`	`object[]`	—
`slice.file`	`string \| null`	—
`slice.gcodeFile`	`string \| null`	—
`slice.gcodeMd5`	`string \| null`	—
`slice.plates`	`integer`	—
`slice.predictionS`	`number \| null`	—
`slice.slicer`	`string \| null`	—
`slice.supportUsed`	`boolean \| null`	—
`slice.weightG`	`number \| null`	—
`supports` optional	`string`	—
`warnings` optional	`string[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_am_prep` write Prepare a metal LPBF build

Body to metal LPBF build (printer: any registry LPBF machine; default DMP Flex 350; cold spray / XJet / MoldJet / metal DLP printers get their DFM pack + STL/STEP/job.json instead) in one call: LPBF DFM (blocking finding refuses unless force), orientation, print body with machining allowance, supports, plate nest, t…

Full description

ime/cost quote, and fil… Call cad_help({tool:"cad_am_prep"}) for the rest.

Argument	Type	Meaning & bounds
`bodies` required	`object[]`	Session bodies to build, each with a copy count. ≥ 1 items · ≤ 16 items
`document` optional	`string`	Document the handles belong to.
`force` optional	`boolean`	Carry on past a blocking DFM finding; it is rec…
`gasFlowAxis` optional	`number[]`	Gas-flow direction in the plate plane… ≥ 2 items · ≤ 3 items
`hip` optional	`boolean`	Include the optional HIP step in the post-proce…
`layerThicknessMm` optional	`number`	CLI slice layer. Default 0.03. > 0 · ≤ 0.2
`machining` optional	`object`	Print-body allowance.
`machining.allowanceMm`	`number`	Stock per face, mm. Default 0.5. > 0 · ≤ 10
`machining.mode`	`enum`	auto: the default faces; none: print body = part. one of "auto", "faces", "none"
`material` optional	`enum`	Alloy. Default Ti64. one of "Ti64", "IN718", "316L"
`orient` optional	`enum \| object`	auto (best of the LPBF orientation search, defa…
`outDir` optional	`string`	Output folder (relative to the output dir).
`plateAttachment` optional	`object`	direct (fused + cut-off stock) or base…
`plateAttachment.cutOff`	`enum`	— one of "wire-edm", "bandsaw"
`plateAttachment.cutOffAllowanceMm`	`number`	— ≥ 0 · ≤ 10
`plateAttachment.mode`	`enum`	— one of "direct", "base"
`postProcess` optional	`boolean`	Cold spray / metal jetting / MoldJet / metal DL…
`printer` optional	`string`	Registry LPBF machine id/alias…
`quote` optional	`object`	LPBF quote (ops/lpbfBuildCost).
`quote.marginPercent`	`number`	Overrides the profile margin… ≥ 0 · ≤ 500
`quote.profile`	`string`	Shop profile id or path.
`quote.quantities`	`integer \| "plate"[]`	Quantity breaks. Default 1, 5, 20, full plate. ≤ 12 items
`recoaterAxis` optional	`number[]`	Recoater travel direction in the plate plane… ≥ 2 items · ≤ 3 items
`refuseOn` optional	`enum`	DFM severity that refuses. Default error. one of "error", "warning"
`shrink` optional	`number[]`	Sintered printers… exactly 3 items
`spacingMm` optional	`number`	Nest spacing between parts. ≥ 0
`stepSchema` optional	`enum`	STEP print-body schema. Default ap214. one of "ap214", "ap242"
`supports` optional	`enum`	auto: LPBF block supports… one of "auto", "none"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_cast_mould` write Design a printed casting mould

Part to a printable two-half ceramic casting mould (Foundry Lab style) in one call: pull + parting, reservoir-on-top orientation, conformal shell (shrink required), split, flange/bolts/keys/vents, cores, gating + charge, solidification check, DFM, STL/3MF/STEP per half, moulds per build, report.

Full description

stopAfter/resume for review. Fields: cad_help.

Argument	Type	Meaning & bounds
`alloy` optional	`string`	Al (default), Zn, Mg or Cu alloy name…
`bodyId` optional	`string`	Session body to mould (or give file).
`ceramicDensityGcc` optional	`number`	Mould ceramic density for half masses. > 0 · ≤ 10
`compensation` optional	`object`	Scan-feedback compensation: {shrink} replaces t…
`copies` optional	`integer`	Moulds wanted; the report gives builds needed. ≥ 1 · ≤ 10000
`document` optional	`string`	Document the handle belongs to.
`draftAllowance` optional	`enum \| number`	Pattern draft allowance on 0 deg moulded walls…
`file` optional	`string`	STEP/STL file to mould instead of a session body.
`medallion` optional	`object`	Charge unit: {massG} or {diameterMm, thicknessMm}.
`medallion.diameterMm`	`number`	— > 0
`medallion.massG`	`number`	— > 0
`medallion.thicknessMm`	`number`	— > 0
`name` optional	`string`	Part name in the report and file names.
`outDir` optional	`string`	Output folder (relative to the output dir).
`resume` optional	`object`	The plan a stopAfter call returned…
`shrink` optional	`object`	REQUIRED linear shrink allowance: {percent}…
`shrink.convention`	`enum`	— one of "multiply", "divide"
`shrink.factor`	`number \| number[]`	—
`shrink.percent`	`number \| number[]`	—
`steps` optional	`object`	Per-step overrides {<step>: {...params} \| {skip…
`stopAfter` optional	`enum`	Stop after this step… one of "import", "moldability", "orientation", "shell", "split", "features", "cores", "gating", "solidification", "dfm", "export", "nest"
`thicknessMm` optional	`number`	Shell wall. Default 6 mm (8 mm Cu). > 0 · ≤ 50
`voxelMm` optional	`number`	Voxel size when the shell takes the voxel route. > 0 · ≤ 20

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_nest` write Nest parts for printing

Nest bodies (with counts) on a plate (bambu_x1c; LPBF dmp_flex_350) or in a powder volume (sls_formlabs_fuse1, sls_eos_p396, mjf_hp_5200, {x,y,z}), prove clearance on the real triangles, write one 3MF (Bambu project, a plate per nest plate; or core 3MF).

Full description

Returns placements, unplaced + reasons, partsPerPlate, utilisation or packingDensity, buildHeight, verify.

Argument	Type	Meaning & bounds
`bodies` required	`object[]`	— ≥ 1 items · ≤ 32 items
`document` optional	`string`	—
`export` optional	`object`	—
`export.bambu`	`object`	—
`export.format`	`enum`	— one of "3mf-bambu", "3mf", "none"
`export.path`	`string`	—
`mode` optional	`enum`	— one of "auto", "3d", "plate"
`orientations` optional	`enum`	— one of "auto", "fixed", "z90", "axis24"
`printer` optional	`string`	—
`searchMs` optional	`integer`	— ≥ 0 · ≤ 120000
`seed` optional	`integer`	—
`spacingMm` optional	`number`	— ≥ 0
`target` optional	`string \| object`	—
`timeBudgetMs` optional	`integer`	— ≥ 100
`wallMarginMm` optional	`number`	— ≥ 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_slice` write Slice for a Bambu Lab X1 Carbon

Slice a body (or a file you already exported) for a Bambu Lab X1 Carbon and return the .gcode.3mf the printer consumes, plus what the slicer measured: print time, filament grams per slot, whether support was used.

Full description

Call cad_help({tool:"cad_slice"}) for the rest.

Argument	Type	Meaning & bounds
`body` optional	`string`	A body handle built in this session…
`document` optional	`string`	Which document to read the body from.
`fallback` optional	`enum`	What to do when no slicer is installed: "estima… one of "estimate", "refuse"
`filaments` optional	`object \| string[]`	One entry per filament slot, in slot order… ≤ 16 items
`file` optional	`string`	A file already on disk to slice: .3mf…
`nozzle` optional	`enum`	Nozzle diameter in mm. one of 0.2, 0.4, 0.6, 0.8
`orient` optional	`enum`	"keep" (the default) slices the part as it is… one of "auto", "keep"
`out` optional	`string`	Where to write the .gcode.3mf.
`overrides` optional	`object`	Raw slicer process keys, e.g. {"sparse_infill_d…
`printer` optional	`string`	The machine: "x1c" (default), or any Bambu Lab…
`process` optional	`string`	Stock process preset name, e.g. "0.20mm Standar…
`supports` optional	`boolean`	Turn support generation on.
`timeoutSec` optional	`integer`	Wall-clock budget for the slice. Default 900 s. ≥ 10 · ≤ 7200

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`method` required	`enum`	"slice": measured by the slicer. one of "slice", "estimate"
`bytes` optional	`integer`	—
`estimate` optional	`object`	estimate only: ops/printEstimate.js's report.
`file` optional	`string \| null`	The .gcode.3mf that was written.
`input` optional	`object`	—
`input.body`	`string \| null`	—
`input.file`	`string`	The file handed to the slicer…
`input.from`	`enum`	— one of "body", "file"
`ms` optional	`integer`	Wall time this call spent.
`plates` optional	`object[]`	slice only: one entry per plate, from Metadata/…
`profile` optional	`object`	What the resulting package says it was built for.
`profile.filaments`	`string \| null[]`	—
`profile.nozzle`	`string \| null`	—
`profile.printer`	`string \| null`	—
`profile.printerVariant`	`string \| null`	—
`profile.process`	`string \| null`	—
`refusal` optional	`object`	estimate only: the coded refusal that stopped a…
`refusal.advice`	`string`	How to install a slicer on this OS.
`refusal.code`	`enum`	— one of "slicer_missing"
`refusal.message`	`string`	—
`slicer` optional	`object`	slice only: which binary ran.
`slicer.bin`	`string`	—
`slicer.flavour`	`enum`	— one of "bambu", "orca"
`slicer.source`	`string`	How it was found…
`slicer.version`	`string \| null`	—
`warnings` optional	`string[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_print` write Send a sliced plate to a Bambu Lab X1 Carbon

Send the .gcode.3mf cad_slice produced to a Bambu Lab X1 Carbon on your LAN and start it: FTPS upload to the SD card, then an MQTT project_file with the AMS trays mapped to the package's filament slots.

Full description

Call cad_help({tool:"cad_print"}) for the rest.

Argument	Type	Meaning & bounds
`accessCode` optional	`string`	LAN Access Code (8 chars).
`amsMapping` optional	`integer[]`	Tray = ams_id * 4 + tray_id. ≤ 16 items
`bedLevelling` optional	`boolean`	Level the bed. Default true.
`bedType` optional	`string`	Plate type.
`ded` optional	`object`	—
`ded.body`	`string`	—
`ded.feed`	`number`	— > 0
`ded.robot`	`string`	—
`ded.bead`	`object`	—
`ded.cell`	`object`	—
`ded.language`	`enum`	— one of "rapid", "krl", "fanuc_tp", "inform"
`ded.layers`	`enum`	— one of "planar", "auto", "conformal"
`ded.out`	`string`	—
`ded.plan`	`object`	—
`ded.post`	`object`	—
`ded.surface`	`object`	—
`file` optional	`string`	The .gcode.3mf from cad_slice.
`flowCali` optional	`boolean`	Flow calibrate. Default true.
`ip` optional	`string`	The printer's IP on your LAN.
`layerInspect` optional	`boolean`	Layer-1 check. Default true.
`mode` optional	`enum`	How to send, or job control. one of "lan", "connect", "pause", "resume", "stop", "ded"
`name` optional	`string`	SD-card file name.
`plate` optional	`integer`	Plate to print. Default 1. ≥ 1 · ≤ 64
`printer` optional	`string`	Saved name or id. Default "x1c".
`serial` optional	`string`	The printer serial.
`timelapse` optional	`boolean`	Default FALSE: timelapse.
`timeoutSec` optional	`integer`	Confirm wait, s. Default 30. ≥ 5 · ≤ 900
`transport` optional	`string`	Force a registry transport.
`useAms` optional	`boolean`	Use the AMS (default true).
`vibrationCali` optional	`boolean`	Vibration cal. Default true.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`mode` required	`enum`	Which answer this is. one of "lan", "connect", "pause", "resume", "stop", "ded"
`amsMapping` optional	`array \| null`	What was sent as ams_mapping.
`amsRows` optional	`array \| null`	The same mapping, labelled.
`bytes` optional	`integer \| null`	—
`ded` optional	`object \| null`	mode ded: language, stats, toolpath, reach, pre…
`file` optional	`string \| null`	The .gcode.3mf on this machine.
`instructions` optional	`string \| null`	What the human must do (mode "connect" only).
`md5` optional	`string \| null`	The md5 the printer re-checks the transfer on.
`ms` optional	`integer`	—
`name` optional	`string \| null`	What the file was stored as on the SD card.
`plate` optional	`integer \| null`	—
`printer` optional	`object \| null`	Which machine answered.
`remote` optional	`string \| null`	Its path on the card.
`request` optional	`object \| null`	The exact project_file request published.
`started` optional	`boolean \| null`	True only if the printer said so itself.
`status` optional	`object \| null`	What the printer last said about itself.
`steps` optional	`array \| null`	What happened, in order.
`url` optional	`string \| null`	The bambu-connect:// link (mode "connect" only).
`useAms` optional	`boolean \| null`	—
`warnings` optional	`string[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_print_status` read Read an X1 Carbon's state and AMS

Ask a Bambu Lab X1 Carbon on your LAN what it is doing: job state, percent, layer, time left, nozzle / bed / chamber temperatures, any HMS faults, and WHAT IS IN EVERY AMS TRAY with the global tray index an ams_mapping uses.

Full description

Call this before a two-colour print to see the real spools, and after cad_print to follow the job. Call cad_help({tool:"cad_print_status"}) for the rest.

Argument	Type	Meaning & bounds
`accessCode` optional	`string`	LAN Access Code (8 chars).
`ip` optional	`string`	The printer's IP on your LAN.
`printer` optional	`string`	Saved name or id. Default "x1c".
`serial` optional	`string`	The printer serial.
`timeoutSec` optional	`integer`	Seconds to wait for the first report. Default 10. ≥ 5 · ≤ 120
`transport` optional	`string`	Force a registry transport.
`watchSec` optional	`number`	Seconds to keep watching. ≥ 0 · ≤ 300

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`status` required	`object \| null`	What the printer last said about itself.
`lines` optional	`object[]`	watchSec only.
`machine` optional	`object`	Bambu machines other than the X1C (CADSF-2506)…
`messages` optional	`integer`	How many reports arrived.
`ms` optional	`integer`	—
`printer` optional	`object \| null`	Which machine answered.
`trays` optional	`object[]`	What the AMS is holding.
`warnings` optional	`string[]`	—
`watchedSec` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_print_in_place_check` write Will the print-in-place part move, and stay together?

PROVE a print-in-place assembly (gears, hinges, chains - printed as one plate, never assembled) both MOVES and can NEVER come apart.

Full description

Call cad_help({tool:"cad_print_in_place_check"}) for the rest.

Argument	Type	Meaning & bounds
`bodies` required	`object[]`	The moving bodies, by handle. Tooth data turns on the gear checks and the screw probe. ≥ 2 items · ≤ 24 items
`document` optional	`string`	Document to read the bodies from.
`gaps` optional	`boolean`	Per-pose gap curve per pair (heat-map data). Default true.
`heatmap` optional	`boolean \| object`	true (or {}) also draws the gap map as a heat-map PNG - hot where two parts come close, cold where they are loose - and returns its path.
`joints` optional	`object[]`	How it moves. The one revolute joint with no drivenBy is the INPUT and turns 360 deg; a body with no joint stands still. ≤ 24 items
`nozzle` optional	`enum`	Defaults layerHeight off the pack. Default 0.4. one of 0.2, 0.4, 0.6, 0.8
`params` optional	`object`	Overrides for the fdm_x1c printInPlace numbers.
`params.blockMargin`	`number`	mm past gapMin that is blocked, not a graze. Default 0.1. ≥ 0
`params.captivityPoses`	`integer`	Of those, how many get the escape probe. Default 8. ≥ 1 · ≤ 72
`params.escapeReach`	`number`	Probe reach, in part sizes. Default 2. > 0
`params.escapeSamples`	`integer`	Probe samples per body. Default 600. ≥ 50 · ≤ 5000
`params.faceCaps`	`boolean`	A ring lip + sun flange hold the planets axially (carrier-less planetary). Default false: warns.
`params.floatFailAboveMm`	`number`	And fails. Default 1.0. ≥ 0
`params.floatWarnAboveMm`	`number`	Carrier-less sun/planet wander that warns. Default 0.55 (just over 2 x the 0.25 mm print gap). ≥ 0
`params.fuseBelow`	`number`	mm; at or under it the pair prints as one. Default 0.15. ≥ 0
`params.gapMin`	`number`	mm, design clearance. Default 0.25. ≥ 0
`params.layerHeight`	`number`	mm; sets the Z floor with zGapMin. > 0
`params.steps`	`integer`	Poses in the sweep. Default 72. ≥ 2 · ≤ 720
`params.tiltDeg`	`number`	Cocking allowed before walking it out. Default 30. ≥ 0 · ≤ 90
`params.zGapMin`	`number`	mm, horizontal floor. Default 0.30. ≥ 0

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`bodies` required	`object[]`	—
`captive` required	`object[]`	—
`gapMap` required	`object`	—
`gapMap.pairs`	`object[]`	—
`gapMap.window`	`number`	—
`ms` required	`integer`	—
`ok` required	`boolean`	—
`params` required	`object`	—
`poses` required	`integer`	—
`verdicts` required	`object[]`	—
`blockedBy` optional	`string[]`	—
`captivityPoses` optional	`integer[]`	—
`floatingTrain` optional	`object \| null`	—
`heatmap` optional	`object`	—
`planetary` optional	`object \| null`	—
`ratios` optional	`object[]`	—
`warnings` optional	`string[]`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_support` write Supports

Grow breakaway supports (tree|grid|linear, fdm|sla) for non-Bambu slicers/resin, or metal supports (profile lpbf: block|line|cone, teeth, fragmentation; lpbf:{params}), proven clear of the part.

Full description

Returns coverage, grams, contact area, removal access; export {path}: 3MF, one object per support.

Argument	Type	Meaning & bounds
`body` required	`string`	—
`bedOnly` optional	`boolean`	—
`blockFaces` optional	`string[]`	—
`buildDirection` optional	`number[]`	—
`companions` optional	`string[]`	—
`cosmeticFaces` optional	`string[]`	—
`density` optional	`number`	—
`document` optional	`string`	—
`export` optional	`object`	—
`interfaceGap` optional	`number`	—
`lpbf` optional	`object`	—
`material` optional	`string`	—
`printer` optional	`string`	—
`profile` optional	`enum`	— one of "fdm", "sla", "lpbf"
`style` optional	`enum`	— one of "tree", "grid", "linear", "block", "line", "cone"
`tipDiameter` optional	`number`	—
`transform` optional	`number[]`	—
`xyGap` optional	`number`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_printer` write Save, list, test and discover LAN 3D printers

Manage the saved-printer list every other print tool's printer argument reads from, so a call can say printer:"my-k2" instead of an ip/serial/access-code triple every time.

Full description

Call cad_help({tool:"cad_printer"}) for the rest.

Argument	Type	Meaning & bounds
`action` required	`enum`	Which operation to run. one of "discover", "add", "list", "remove", "test"
`credentials` optional	`object`	add only: secrets for this machine, stored in t…
`credentials.apiKey`	`string`	—
`credentials.code`	`string`	—
`credentials.key`	`string`	—
`credentials.kind`	`enum`	— one of "access-code", "api-key", "basic", "digest", "none"
`credentials.password`	`string`	—
`credentials.secret`	`string`	—
`credentials.token`	`string`	—
`credentials.username`	`string`	—
`host` optional	`string`	add only: IP or hostname on your LAN.
`name` optional	`string`	Saved printer name. Required for add/remove/test.
`port` optional	`integer`	add only: overrides the transport's default port. ≥ 1 · ≤ 65535
`printer` optional	`string`	add only: registry id or alias…
`protocols` optional	`enum[]`	discover only: which LAN protocols to probe.
`serial` optional	`string`	add only: device serial.
`timeoutMs` optional	`integer`	discover/test only. Default 3000/5000. ≥ 100 · ≤ 10000
`transport` optional	`string`	add only: force one of the printer's registry t…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`action` optional	`enum`	— one of "discover", "add", "list", "remove", "test"
`addedAt` optional	`string \| null`	—
`capabilities` optional	`object \| null`	—
`code` optional	`string \| null`	—
`conn` optional	`object \| null`	—
`count` optional	`integer \| null`	—
`details` optional	`object \| null`	—
`found` optional	`array \| null`	—
`hasCredentials` optional	`boolean \| null`	—
`host` optional	`string \| null`	—
`name` optional	`string \| null`	—
`ok` optional	`boolean \| null`	—
`port` optional	`integer \| null`	—
`printer` optional	`string \| null`	—
`printers` optional	`array \| null`	—
`removed` optional	`boolean \| null`	—
`serial` optional	`string \| null`	—
`transport` optional	`string \| null`	—

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Server, config & licence · 6

Session setup: where files are written, what this build is, and the licence the seat is running under.

`cad_configure` write Configure runtime limits

Read or change the server's runtime limits: memory budgets (maxBytes hard cap, warnBytes soft threshold), the per-request tessellation ceiling (maxTriangles), and the export output directory.

Full description

Call with no arguments to read the current settings. Pass a value to set it, or null to clear it back to its default. Call cad_help({tool:"cad_configure"}) for the rest.

Argument	Type	Meaning & bounds
`addon` optional	`object`	Space Program add-on: {action:status\|install\|op…
`autoUpdate` optional	`enum`	How NativeCAD takes new releases: auto installs… one of "off", "notify", "auto", null
`batchSoftDeadlineMs` optional	`integer \| null`	ms before a still-running cad_batch op becomes… ≥ 0
`booleanFuzzy` optional	`number \| null`	Session-default boolean fuzzy value, mm: operan… ≥ 0
`booleanIdentityTolerance` optional	`number \| null`	Relative delta (0.01 = 1%) at which a boolean i… > 0 · ≤ 1
`captureGeometry` optional	`enum`	OFF by default, and the ONLY switch that upload… one of "on", "off", null
`maxBytes` optional	`integer \| null`	Hard cap on in-memory model bytes; above it new… ≥ 1048576
`maxTriangles` optional	`integer \| null`	Per-request cap on triangles a tessellation/exp… ≥ 1000
`opTimeoutMs` optional	`integer \| null`	Wall-clock ceiling on ONE modelling call, in ms. ≥ 0
`outputDirectory` optional	`string \| null`	Absolute directory that cad_export_body's relat…
`solvers` optional	`enum`	status: list FEA solvers found. one of "status"
`telemetry` optional	`enum`	Anonymous usage log… one of "on", "off", null
`update` optional	`enum`	check: look for a release now. one of "check", "now"
`updateChannel` optional	`enum`	Release channel. one of "stable", "beta", null
`warnBytes` optional	`integer \| null`	Soft threshold; crossing it sets headroom.softW… ≥ 1048576

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`changed` optional	`string[]`	—
`defaults` optional	`object`	—
`note` optional	`string`	Present when a setting was accepted but does no…
`settings` optional	`object`	—
`settings.batchSoftDeadlineMs`	`integer \| null`	—
`settings.booleanFuzzy`	`number \| null`	—
`settings.booleanIdentityTolerance`	`number \| null`	—
`settings.captureGeometry`	`enum`	— one of "on", "off"
`settings.maxBytes`	`integer \| null`	—
`settings.maxTriangles`	`integer \| null`	—
`settings.opTimeoutMs`	`integer \| null`	—
`settings.outputDirectory`	`string \| null`	—
`settings.telemetry`	`enum`	— one of "on", "off"
`settings.warnBytes`	`integer \| null`	—

`cad_server_info` read Server capabilities and inventory

Describe this NativeCAD MCP build: every registered tool grouped by subsystem, the optional subsystems present or absent, the full error-code vocabulary with recoverability, and the unit conventions.

Full description

Call this first when you are unsure what the server can do — the tool surface varies by build, and this is the only authoritative answer.

Argument	Type	Meaning & bounds
`section` optional	`enum`	One section only. Default "all". one of "all", "tools", "errors", "services", "conventions", "solvers" · default `"all"`

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`server` required	`object`	—
`server.name`	`string`	—
`server.version`	`string`	—
`server.displayName`	`string`	—
`server.kernelVersion`	`string \| null`	—
`server.node`	`string`	—
`server.transport`	`string`	—

`cad_license` write License status, activation and free registration

Report or set this server's NativeCAD licence, or get the free-registration link.

Full description

Validates OFFLINE, no network call. Three states: UNREGISTERED builds freely but gates the ten tools that move geometry off this machine; a FREE registered key opens the full toolset on Education / Maker terms; a paid seat adds commercial rights. Call cad_help({tool:"cad_license"}) for the rest.

Argument	Type	Meaning & bounds
`action` optional	`enum`	"status" reads the current licence (default); "… one of "status", "activate", "deactivate", "register" · default `"status"`
`key` optional	`string`	The licence key, format CSLV1-<payload>-<tag>.

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`gated` required	`boolean`	True when this server is unregistered, i.e. whe…
`licensed` required	`boolean`	—
`licensee` required	`string \| null`	—
`source` required	`enum`	Where the active key came from: "env" the envir… one of "env", "file", "tool", "none"
`tier` required	`string \| null`	free is the registered Education / Maker tier…
`action` optional	`string`	—
`changed` optional	`boolean`	True when this call actually flipped the licenc…
`envKey` optional	`string`	—
`expired` optional	`object \| null`	Set when the key this install was given has run…
`expires` optional	`string \| null`	YYYY-MM-DD, or null for a seat with no end.
`fileEnvKey` optional	`string`	Env var that relocates the licence file.
`gatedWithoutKey` optional	`string[]`	The tools REFUSED while unregistered — the on…
`hint` optional	`string`	—
`licenseFile` optional	`string \| null`	Absolute path of the stored licence — where a…
`notice` optional	`string \| null`	—
`persisted` optional	`boolean`	activate/deactivate: whether disk was written o…
`registerUrl` optional	`string`	—
`steps` optional	`string[]`	action "register": what a human does.
`tiers` optional	`string[]`	—
`updatesUntil` optional	`string \| null`	YYYY-MM-DD, informational: the end of the UPDAT…
`warning` optional	`string \| null`	—

`cad_help` read Full description for one tool

Return the full, untrimmed description for one tool named in tools/list (a description ending "Call cad_help(...)" was cut to fit), or a playbook by topic, e.g.

Full description

"composites". Safe to call speculatively.

Argument	Type	Meaning & bounds
`action` optional	`string`	With tool: one action's arguments, e.g. "diff".
`format` optional	`string`	With tool: one format's option block, e.g. "glb".
`tool` optional	`string`	A tool name from tools/list, e.g. "cad_export_b…
`topic` optional	`enum`	— one of "eval-loop", "drawings", "pcb", "cert", "field", "thread", "constrain_face", "glazing", "composites", "turbomachine", "retro", "continuity", "offset-first", "addon"

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

`cad_report_bug` write Report a NativeCAD bug

File a bug about NATIVECAD ITSELF (not the part you are modelling) directly from this session.

Full description

Call cad_help({tool:"cad_report_bug"}) for the rest.

Argument	Type	Meaning & bounds
`description` required	`string`	Full description.
`title` required	`string`	What went wrong, in one line.
`actual` optional	`string`	What actually happened. Truncated at 4096 bytes.
`attachFile` optional	`string`	OPT-IN.
`attachMode` optional	`enum`	extract (default): only the minimal extract of… one of "extract", "original" · default `"extract"`
`attested` optional	`boolean`	Your attestation, with the wording returned by… default `false`
`consentToken` optional	`string`	The token the preview returned.
`contact` optional	`object`	Sent only with an attachment.
`contact.email`	`string`	Where we reach you about this file.
`contact.company`	`string`	—
`contact.name`	`string`	—
`expected` optional	`string`	What you expected instead.
`failure` optional	`object`	Where the reader failed; steers which fragment…
`failure.code`	`string`	—
`failure.entityId`	`integer`	STEP entity number the reader failed at, if it…
`failure.stage`	`string`	—
`failureFingerprint` optional	`string`	Fingerprint (hex) of the automatic failure repo…
`includeEmail` optional	`boolean`	Attach your own reply-to email, read from CADSO… default `false`
`severity` optional	`enum`	blocker \| major (default) \| minor \| cosmetic. one of "blocker", "major", "minor", "cosmetic" · default `"major"`
`steps` optional	`string`	How to reproduce it. Truncated at 4096 bytes.
`tool` optional	`string`	The cad_* tool that misbehaved, if this is abou…

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Field	Type	Meaning & bounds
`id` required	`string \| null`	The listener's report id, when it sent one back.
`localCopy` required	`string \| null`	Path to the local JSONL log this report was app…
`receipt` required	`string`	A line to quote support with, whether or not th…
`sent` required	`boolean`	True when the bug listener accepted the report.
`attachment` optional	`object`	Present when attachFile was given: status…
`foundIn` optional	`string`	Version this was filed against — pass it as f…
`reason` optional	`string`	Present only when sent is false: why the POST d…

`cad_gpu` write GPU acceleration: status / install / benchmark / remove

Manage the OPTIONAL WebGPU addon (dawn.node) this server can use for GPU-accelerated kernels.

Full description

ASK THE USER BEFORE calling install: it downloads a ~20 MB binary from the npm registry (or a local file via fromFile for an air-gapped install). Call cad_help({tool:"cad_gpu"}) for the rest.

Argument	Type	Meaning & bounds
`action` required	`enum`	"status": read-only report. one of "status", "install", "benchmark", "remove"
`fromFile` optional	`string`	Only used with action:"install".

No other keys are accepted; an unknown argument is an E_ARGS refusal rather than a silent ignore.

Result

Returns no structured fields.

The tool reference

Conventions

Errors are refusals, and they tell you what to do

The tools

Primitives & sketches · 15

cad_box write Box

cad_cylinder write Cylinder

cad_cone write Cone

cad_frustum write Frustum

cad_sphere write Sphere

cad_torus write Torus

cad_polyhedron write Polyhedron

cad_planar_sheet write Planar sheet

cad_create_sketch write Create sketch

cad_dice_pips write Engrave dice pips

cad_padstack write Padstack

cad_trace_section write Trace section

cad_glass_weave write Glass Weave

cad_gear write Gear

cad_sketch_solve write Solve a constrained 2D sketch

Result

Features · 38

cad_pad write Pad

cad_extrude_profile write Extrude profile

cad_revolve_profile write Revolve profile

cad_sweep_profile write Sweep profile along a path

cad_tube_sweep write Tube sweep

cad_laminate write Laminate

cad_lattice_fill write Lattice fill

cad_picogk write

cad_weave write Weave

cad_loft_profiles write Loft profiles

cad_loft_guided write Guided loft

cad_blade write Blade

cad_thicken destructive Thicken

cad_shell destructive Shell

cad_rib write Rib

cad_draft destructive Draft

cad_fillet_edges destructive Fillet edges

cad_face_blend destructive Face blend / full round

cad_ease_edges destructive Ease exposed edges

cad_chamfer_edges destructive Chamfer edges

cad_drill_hole destructive Drill hole

cad_hole_pattern write Hole pattern

cad_feature_pattern destructive Pattern a feature (pad / pocket / hole) inside one body

cad_engrave_text write Engrave text

cad_pushpull destructive Push / pull a face

cad_move_face destructive Move face

cad_delete_face destructive Delete face

cad_sheet_fold write Sheet fold

cad_sheet_box write Sheet box

cad_offset_faces destructive Offset region (offset a face set)

cad_replace_face destructive Replace face

cad_face_region destructive Face region

cad_defeature destructive Defeature (simplify by detail size)

cad_sheet_feature write Sheet feature

cad_sheet_miter write Sheet miter

cad_sheet_convert write Sheet convert

cad_corner_relief write Corner relief

cad_enclosure write Electronics enclosure from an envelope

Freeform surfacing · 17

cad_boundary_surface write Boundary surface

cad_ruled_surface write Ruled surface

cad_offset_surface write Offset surface

cad_flatten_surface write Flatten surface

cad_mutual_trim write Mutual trim

cad_net_surface write Net surface

cad_fill_patch write Fill patch

cad_untrim_face write Untrim face

cad_extend_face write Extend face

cad_fit_curve write Fit a curve through points

cad_fit_surface write Fit a surface through points

cad_mesh_to_brep write Mesh to B-rep

cad_mesh_section write Mesh section

cad_mesh_compare read Compare mesh to body

cad_surface_analysis read Surface analysis (class A)

Result

cad_crease_repair destructive Crease repair

cad_shell_from_outline write Shell from outline

Booleans, transforms & patterns · 13

`cad_box` write Box

`cad_cylinder` write Cylinder

`cad_cone` write Cone

`cad_frustum` write Frustum

`cad_sphere` write Sphere

`cad_torus` write Torus

`cad_polyhedron` write Polyhedron

`cad_planar_sheet` write Planar sheet

`cad_create_sketch` write Create sketch

`cad_dice_pips` write Engrave dice pips

`cad_padstack` write Padstack

`cad_trace_section` write Trace section

`cad_glass_weave` write Glass Weave

`cad_gear` write Gear

`cad_sketch_solve` write Solve a constrained 2D sketch

`cad_pad` write Pad

`cad_extrude_profile` write Extrude profile

`cad_revolve_profile` write Revolve profile

`cad_sweep_profile` write Sweep profile along a path

`cad_tube_sweep` write Tube sweep

`cad_laminate` write Laminate

`cad_lattice_fill` write Lattice fill

`cad_picogk` write

`cad_weave` write Weave

`cad_loft_profiles` write Loft profiles

`cad_loft_guided` write Guided loft

`cad_blade` write Blade

`cad_thicken` destructive Thicken

`cad_shell` destructive Shell

`cad_rib` write Rib

`cad_draft` destructive Draft

`cad_fillet_edges` destructive Fillet edges

`cad_face_blend` destructive Face blend / full round

`cad_ease_edges` destructive Ease exposed edges

`cad_chamfer_edges` destructive Chamfer edges

`cad_drill_hole` destructive Drill hole

`cad_hole_pattern` write Hole pattern

`cad_feature_pattern` destructive Pattern a feature (pad / pocket / hole) inside one body

`cad_engrave_text` write Engrave text

`cad_pushpull` destructive Push / pull a face

`cad_move_face` destructive Move face

`cad_delete_face` destructive Delete face

`cad_sheet_fold` write Sheet fold

`cad_sheet_box` write Sheet box

`cad_offset_faces` destructive Offset region (offset a face set)

`cad_replace_face` destructive Replace face

`cad_face_region` destructive Face region

`cad_defeature` destructive Defeature (simplify by detail size)

`cad_sheet_feature` write Sheet feature

`cad_sheet_miter` write Sheet miter

`cad_sheet_convert` write Sheet convert

`cad_corner_relief` write Corner relief

`cad_enclosure` write Electronics enclosure from an envelope

`cad_boundary_surface` write Boundary surface

`cad_ruled_surface` write Ruled surface

`cad_offset_surface` write Offset surface

`cad_flatten_surface` write Flatten surface

`cad_mutual_trim` write Mutual trim

`cad_net_surface` write Net surface

`cad_fill_patch` write Fill patch

`cad_untrim_face` write Untrim face

`cad_extend_face` write Extend face

`cad_fit_curve` write Fit a curve through points

`cad_fit_surface` write Fit a surface through points

`cad_mesh_to_brep` write Mesh to B-rep

`cad_mesh_section` write Mesh section

`cad_mesh_compare` read Compare mesh to body

`cad_surface_analysis` read Surface analysis (class A)

`cad_crease_repair` destructive Crease repair

`cad_shell_from_outline` write Shell from outline

`cad_boolean_union` destructive Boolean union

`cad_boolean_subtract` destructive Boolean subtract

`cad_boolean_intersect` destructive Boolean intersect

`cad_transform` write Transform

`cad_mirror` write Mirror

`cad_copy` write Copy

`cad_pattern_copies` write Pattern copies

`cad_split_plane` destructive Split by plane

`cad_split_face` destructive Split face

`cad_split_edge` destructive Split edge