Socket Types & Conversions

Every wire in a Node Sculptor graph carries a typed value. Nine socket types, a small set of implicit conversions the evaluator does silently for you, and a deliberately short list of conversions it refuses to do so you don't shoot your foot off.

Each type has a fixed colour, so you can read a graph by the wires alone.

Socket Types

Float: Single 32-bit floating-point number. Yellow socket. Scalars, radii, angles, gains \u2014 the bread-and-butter.
Int: 32-bit integer. Yellow socket with a tick. Counts, indices, seeds, segment counts.
Vector3: [x, y, z] triple in world millimetres. Blue-green socket. Positions, axes, offsets.
PointArray: Array of Vector3s. White socket. Generic point cloud / scalar stream \u2014 Field nodes also abuse this type to pass per-sample scalars via the x channel (see "Scalar Fields" below).
Path: Ordered polyline \u2014 same shape as PointArray, but semantically "a curve you can sweep / stack / slice". White socket with a curve glyph.
Region: Planar area = outer Path + array of hole Paths. Passed between face-builders (e.g. Voronoi 2D) and area consumers (Extrude). Lets holes travel as first-class geometry.
Mesh: Triangle mesh { positions, indices, normals? }. Grey socket. The output of Surfaces & Mesh.
SDF: A function (p) => distance. Not serialised \u2014 lives only inside a single graph evaluation. Purple socket. Combine via sdfUnion / Subtract / Intersect, polygonise with Marching Cubes.
Toolpath: Array of ToolpathSegments \u2014 each a polyline with optional speed / flow overrides and an isTravel flag. Orange socket. The Output node's primary print input.

Implicit Conversions

The evaluator accepts these cross-type connections automatically \u2014 the UI shows them as valid drop targets and coerces values before the downstream executor runs:

Int \u2192 Float: Identity cast.
Float \u2192 Int: Rounded to nearest integer.
Float \u2192 Vector3: Scalar broadcast \u2014 the value is replicated across all three axes, i.e. (v, v, v).
Vector3 \u2192 PointArray: Single-element list.
Vector3 \u2192 Path: Single-point degenerate path.
Path \u2192 PointArray: Treats the polyline as a list of points (drops the "closed loop" semantics).
PointArray \u2192 Path: Treats the list as an open polyline.
Path \u2192 Toolpath: Wraps the polyline in a single Toolpath segment at printer default speed / flow.
PointArray \u2192 Toolpath: Same as Path \u2192 Toolpath, but driven from a point list.
Path \u2192 Region: Wraps a closed Path as a Region with no holes. Lets Extrude accept a plain rectangle / circle without an explicit face-builder.
Mesh \u2192 PointArray: Identity passthrough used by the polymorphic transform nodes (Move / Rotate / Scale / Mirror / Array Linear / Array Polar). The input is declared PointArray for nominal typing, but the executor dispatches on the runtime value type and produces a matching output \u2014 a Mesh stays a Mesh through the chain.
Toolpath \u2192 PointArray: Identity passthrough \u2014 same rationale as Mesh \u2192 PointArray. Lets a Toolpath flow through transform nodes without losing per-segment metadata.

Conversions That Are Deliberately NOT Implicit

Some conversions are heavy enough, or lossy enough, that forcing you to insert an explicit node keeps the cost and the choice visible:

SDF \u2192 Mesh: Use Marching Cubes. Resolution drives cost cubically (O(n\u00b3)), so hiding that behind an implicit conversion would be a performance trap waiting to happen.
Mesh \u2192 Toolpath: Use Contour Slice. Layer height, z-start and epsilon are significant choices that belong on a dedicated node.
Vector3 \u2192 Float / Int: Use Decompose Vector or Vector Length. Picking which component (x / y / z / magnitude) is a deliberate choice.
Toolpath \u2192 Path: A Toolpath is a list of segments; flattening it to a single Path is ambiguous (concatenate? interleave travels? insert seams?). If you really need it, write a small helper path.

Required Inputs vs Defaults

Every input socket is declared either:

Required (required: true in the descriptor). If nothing is wired in and no upstream value exists, the evaluator adds a missing-input problem to the Problems panel and the node emits its empty fallback value (empty Path, empty Mesh, zero Toolpath, …). Downstream nodes keep running so you can still iterate on the rest of the graph.
Optional with a default. Most Float / Int / Vector3 inputs have an in-node parameter twin that provides the default when the socket is unconnected. Plugging a wire in overrides the parameter.

Scalar Fields as PointArrays

Field nodes \u2014 Point Attractor, Noise Field, Wave Field, Curve Attractor \u2014 emit their result as a PointArray where the x-channel of each point holds the scalar value and y / z are unused. Modulate Path and Modulate Toolpath read that same convention.

It's a little cheeky, but it pays off: every field output is also a valid geometry stream you can preview as a point cloud for debugging. If you need just the scalars, Decompose Vector on one sample or List Item at a known index hands you a Float.

Toolpath Segments

A Toolpath is an ordered list of segments. Each segment carries:

points: [x, y, z] polyline in world mm. For Vase Spiralizer the entire print is one long segment; for Layer Stacker each layer is its own.
isTravel: Optional. When true, the G-code compiler emits a travel move (retract + fast XY + unretract) instead of a print move. Modulate Toolpath skips these by default.
speedMmPerMin: Optional per-segment speed override. Falls back to the printer config print speed.
flowMultiplier: Optional per-segment flow multiplier \u2014 1.0 is nominal, >1 over-extrudes, <1 under-extrudes. Used by Flow Modulate, consumed by the G-code compiler.

Segments are independent \u2014 no implicit travel is inserted between them. If you need the printer to lift and re-position between layers, either stack Toolpath segments from a node that understands layering (Layer Stacker, Contour Slice) or prepend your own travel segment with isTravel: true.