Dingcad Manifold AST operations

Use the normal authenticated HTTP commit API, exactly ONE putNode/putPart/delete
operation per request, then poll evaluation feedback. This is data, never JS code.
The main protocol reference is https://dingcad.com/live-api.txt.
Machine-readable operation inventory: https://dingcad.com/live-operations.json.

Every node: {id,op,inputs:[node IDs],params:[numbers],...documented fields}.
Children must exist before adding a parent. Part roots MUST be solids. CrossSection
nodes are intermediate 2D profiles; use extrudeSection/revolveSection to make a
visible solid. Each relevant physical object should remain its own named part.
All positions/lengths are mm, angles degrees, matrices column-major.
Transforms return new values; upstream nodes and unrelated parts remain unchanged.
Optional color:[r,g,b] belongs on a solid; every part needs color:[r,g,b].

Original nodes (unchanged)
box [x,y,z], sphere [radius], cylinder [height,radius]: zero inputs, centered.
translate/rotate/scale [x,y,z]: one solid input.
union/difference/intersection/hull []: two solid inputs. A single-body hull may
reference the same child twice. Balance long boolean chains.
mesh []: uploaded STL asset hash and bounds; see main guide.
extrude [height], revolve [degrees]: literal profile:[contour,...]; see main guide.
segments 4–128 applies to sphere/cylinder/revolve (default 32, revolve 48).

Additional solid constructors (zero inputs)
tetrahedron []: native unit tetrahedron; scale/translate to size/place it.
cone [height,radiusLow,radiusHigh]: centered Z; either radius may be zero,
  not both. Optional segments 4–128, default 32.
hullPoints [] with points:[[x,y,z],...]: convex hull of 4–256 finite points.
levelSet [edgeLength,level,tolerance] with bounds:[[minX,minY,minZ],[maxX,maxY,maxZ]]
  and expressions:[scalar]: bounded signed-distance/implicit field. Positive is
  inside. Edge length >0; tolerance >=0. At most 32768 estimated grid samples.
  Increase edgeLength if the preflight rejects a large field.

Additional solid operations (one solid input unless specified)
transform [16 affine matrix values]: translation in elements 12,13,14; final
  row [0,0,0,1]. Nonsingular. Example identity translated 10 mm on X:
  [1,0,0,0, 0,1,0,0, 0,0,1,0, 10,0,0,1].
mirror [nx,ny,nz]: reflect through the origin plane with this nonzero normal.
trimByPlane [nx,ny,nz,offset]: keep the half-space in the normal direction.
splitByPlane [nx,ny,nz,offset,side]: side 0 keeps the normal side, 1 the other.
split [side]: TWO solid inputs (body,cutter); 0 intersection, 1 remainder.
  Add two individually committed split nodes if you want to retain both pieces.
compose []: TWO disjoint solid inputs; concatenate without a boolean. Use union
  for overlapping objects. Repeated compose nodes form a balanced assembly tree.
decompose [index]: select a disconnected component, index 0–255; errors if absent.
  Component indices follow the kernel and may change after geometry edits.
asOriginal []: make a new provenance root (normally managed automatically).
smooth [] with optional options:{sharpenedEdges:[{halfedge,smoothness},...]}:
  construct tangent smoothing from the input mesh. At most 256 edge rules;
  smoothness 0–1. Follow with refine to create actual curved mesh geometry.
smoothOut [minSharpAngle,minSmoothness]: angle 0–180, smoothness 0–1;
  set tangent smoothing, then refine to materialize it.
refine [divisions]: integer 2–16. Preflight: inputTriangles * divisions^2 <=100000.
refineToLength [length], refineToTolerance [tolerance]: positive; conservative
  subdivision preflight based on the input diagonal and requested spacing.
setTolerance [tolerance]: positive; may simplify geometry as tolerance increases.
simplify [tolerance]: nonnegative, using the native kernel's simplification.
calculateNormals [firstPropertyChannel,minSharpAngle]: channel 0–5, angle 0–180.
smoothByNormals [firstPropertyChannel]: channel 0–5; three existing normal
  channels required. Use calculateNormals first if they do not exist.
calculateCurvature [gaussianChannel,meanChannel]: distinct channels 0–7.
setProperties [count] with expressions:[...count scalars]: count 0–8; replace
  property channels using coordinate and previous-property expressions.
warp [] with expressions:[newX,newY,newZ]: vertex warp. Refine first if needed
  for curved deformation; a warp does not add vertices or repair self-crossings.

CrossSection constructors (zero inputs)
square2d [width,height]: centered XY rectangle.
circle2d [radius]: optional segments 4–128, default 32.
profile2d [] with profile:[contour,...], optional options:{fillRule}:
  1–16 contours, 3+ points each, at most 256 total XY points. Implicit closure.
  fillRule is EvenOdd (default), NonZero, Positive or Negative. Unlike the legacy
  extrude/revolve literal profile, native CrossSection resolves crossings/fill.

CrossSection operations (one section input unless specified)
translate2d [x,y], rotate2d [degrees], scale2d [x,y], mirror2d [nx,ny].
transform2d [9 affine values]: final row [0,0,1]; translation elements 6,7.
warp2d [] with expressions:[newX,newY].
offset2d [delta,miterLimit] with optional options:{joinType} and segments:
  miterLimit 1–100; joinType Round (default), Square or Miter; segments 4–128.
  Positive delta expands, negative shrinks. Offset tessellation is preflighted.
simplify2d [epsilon]: nonnegative contour simplification distance.
union2d/difference2d/intersection2d/hull2d/compose2d []: TWO section inputs.
  Compose assumes disjoint sections. For a single hull use the same input twice.
decompose2d [index]: select one disconnected profile component, index 0–255.
slice [height]: ONE SOLID input -> section at the specified Z.
project []: ONE SOLID input -> XY projected section.

Convert a section to a solid (one section input)
extrudeSection [height,divisions,twistDegrees,scaleTopX,scaleTopY,center]:
  height >0, divisions 0–128, twist ±3600 degrees, top scales 0–10000,
  center 0 or 1. Use [height,0,0,1,1,1] for a plain centered extrusion.
revolveSection [degrees]: 0 < degrees <=360. Optional segments 4–128,
  default 48. Profile X is radius, Y becomes Z. Only positive X is revolved.
Both preflight profile vertex count against tessellation limits.

Expression AST (warp, warp2d, levelSet, setProperties)
A scalar is a finite numeric constant, coordinate "x"/"y"/"z", or an array:
  [operator, child, ...]. Coordinates always refer to the ORIGINAL input vertex,
  so expressions:["y","x","z"] swaps X/Y simultaneously.
Unary: neg,abs,sqrt,sin,cos,tan,asin,acos,atan,exp,log,floor,ceil,round.
Binary: +,-,*,/,min,max,pow,atan2,mod,lt,gt.
Ternary: clamp(value,min,max), select(condition,whenNonzero,whenZero).
All branches are evaluated; avoid invalid arithmetic even in an unused branch.
Trigonometric expression functions use RADIANS (node rotation parameters use degrees).
setProperties also accepts "p0" through "p7" for prior property channels; missing
channels read as zero. No other strings, functions, source code or globals.
At most 256 expression terms per node and depth 16; constants within ±1e6.
Nonfinite/intermediate magnitudes above 1e7 fail with evaluation feedback.
Example raised-wave warp:
  {"id":"wave","op":"warp","inputs":["refined"],"params":[],
   "expressions":["x","y",["+","z",["*",2,["sin",["*",0.1,"x"]]]]]}
Example radius-5 implicit sphere field (positive inside):
  {"id":"implicit","op":"levelSet","inputs":[],"params":[1,0,0],
   "bounds":[[-6,-6,-6],[6,6,6]],
   "expressions":[["-",5,["sqrt",["+",["+",["*","x","x"],["*","y","y"]],["*","z","z"]]]]]}

Limits and feedback
Limits remain in force: 8192 nodes, 256 parts, dependency depth 64, 2 MiB graph,
100000 triangles per result, 12 MiB rendered vertex buffers; see main guide for
job/cache limits. A section result is capped at 32768 vertices. Every saved edit
still requires successful browser evaluation feedback before the next edit.
Native errors, missing component/channel errors, expression failures and budgets
are returned through the normal evaluation protocol. Do not mask or skip errors.

Scope
These nodes cover modeling methods exposed by the installed Manifold binary.
Overloaded aliases and batch forms map to the binary AST nodes above. Engine
setup/delete/IDs/global circular defaults are managed internally. Measurements,
triangulation/mesh serialization and kernel metadata are not shape-building nodes.
Newer upstream Minkowski operations are not present in this installed binary;
do not request or claim them. Check the inventory rather than guessing a name.