@parametron/parametric#

Model JSON
     │
     ▼
┌──────────┐     ┌───────────┐     ┌───────────────┐
│  Schema  │────▶│   Model    │────▶│ NodeCollection │
│ (parse)  │     │ (fromJSON) │     │  (build graph) │
└──────────┘     └───────────┘     └───────────────┘
                       │
                       ▼
               ┌──────────────┐
               │   evaluate() │
               │  (pull-based) │
               └──────┬───────┘
                      │
          ┌───────────┴───────────┐
          ▼                       ▼
    parameters (header)     operations (body)
    key → VALUE bindings    ONE fold, top-down:
    (resolve values)        producers concat, transforms
          │                 process, containers nest
          └───────────┬───────────┘
                      ▼
              EvaluateResult
              { geometry, materials, params }

operation  { key?, label?, enabled?, method, args? }          ← does something to the stream
container  { key?, label?, enabled?, operations: NodeJSON[] } ← holds a list of nodes

container "cabinet"
 ├── operation rectangle          ← producer: concats its result into the stream
 ├── operation extrude            ← producer (a solid = Face[])
 ├── operation edgeFillet         ← transform: processes the stream (map)
 ├── operation arrayLinear        ← transform (multiply, n → m)
 └── container "doors"            ← nested fold: runs its own list from an
      ├── operation rectangle        empty stream, result concats into the
      └── operation curveExtrude     parent stream like a producer

"1200"              → literal number
"lengthX - thickness" → references parameters by key
"flag ? 10 : 20"   → ternary
"'Oak'"             → literal text (single-quoted)
"[0,0,lengthZ]"      → array/vector

1. Model.fromJSON(json)
   ├── Parse ModelJSON (schema.ts)
   ├── Build NodeCollection (flat → tree)
   └── Wire expression dependencies

2. model.evaluate(params, resolveDep?)
   ├── Resolve parameters (with overrides from params)
   │   └── Expression evaluation (jsep parse → resolve refs → compute)
   ├── Run the body fold (operations, top-down)
   │   └── producers create geometry, transforms process the stream
   └── Collect results → EvaluateResult
       ├── geometry: GeometryNode[] (tree of entities)
       ├── materials: MaterialData[] (PBR materials)
       └── params: ParamInfo[] (exposed parameters)

Point   (geometry [x,y,z], namespace pointEntity)
            position markers for visualizing locations (render-only)
            producers: pointEntity

Curve   (geometry NurbsCurveJSON, namespace curveEntity)
            1D wires AND closed loops (a closed loop is still a Curve)
            producers: polyline, spline, rectangle, polygon,
                        arcCenterStartEnd, arcThreePoints, arcTangentEnd,
                        circle, ellipseArc, cubicBezier, quadraticBezier,
                        nurbsCurve, textCurve

Face    (geometry { loops, uvMatrix }, namespace faceEntity)
            flat 3-D polygon region (holes via extra loops); a solid = Face[]
            producers: extrude, sweep, loft, revolve,
                        patchFromCurve, patchFromCorners

src/
├── schema.ts          # TypeScript types for JSON format
├── schema/types.ts    # Core value/entity type catalog (TypeDef; a RegistryInput can add inert types)
├── registry/          # Node contract + registry (the engine's INPUT)
│   ├── contract.ts    # RegistryInput / NodeDefinition / ChainGroup / ArgDef
│   ├── Registry.ts    # createRegistry(input) — merge + validate, per-Model instance
│   ├── builtins.ts    # CORE_NODES (engine builtin node definitions + preload hooks)
│   └── helpers.ts     # chain helpers (group/applyGeometry/multiplyInstances/mapInstances/…)
├── validate.ts        # Model/node validation (Zod structure + registry pass)
├── Model.ts           # Model class (fromJSON({registry}), evaluate)
├── evaluate.ts        # evaluateModel(json, params, { registry, assets }) — sync
├── domains/           # Producer/transform implementations per domain
│   ├── curve.ts       # curveEntity producers
│   ├── face.ts        # faceEntity producers
│   ├── solid.ts       # solid/face transforms (solidUnion/solidSubtract/solidIntersect/solidSelfUnion, faceExtrude/edgeFillet/edgeChamfer…)
│   ├── surface.ts     # curved producers (loft/revolve/sweep/patchFromCurve/patchFromCorners → Face[])
│   ├── point.ts       # pointEntity producers
│   ├── entity.ts      # generic per-entity transforms (reverse/resize/applyMaterial/applyLayer/…)
│   ├── entities.ts    # whole-stream ops (move/rotate/array*/mirror/clone/…)
│   ├── font.ts        # font lookup/fallback (fonts[] static lane, not a parameter)
│   └── …            # (namespaces are registered per RegistryInput — see nodesRegistry/)
├── nodesRegistry/     # ParaShape's own node set (the `/nodes` subpath — optional, never
│   ├── catalog.ts     #   pulled in unless imported)
│   ├── functionRegistry.ts
│   ├── namespaces.ts
│   └── wiring.ts       # catalog entry → OperationDefinition, wired to domains/* compute
├── core/              # BaseObject, collections, ModelScope (model), sanitizer
├── nodes/             # Runtime node classes
│   ├── BaseNode.ts
│   ├── ParameterNode.ts
│   ├── OperationNode.ts # one fold step (producer/transform, per-step cache)
│   ├── ContainerNode.ts # container form + FoldRunner
│   ├── ExpressionNode.ts
│   ├── ArgumentNode.ts
│   ├── OptionNode.ts
│   └── NodeCollection.ts
└── utils/
    ├── expression.ts  # Expression parser/evaluator
    ├── convertExpression.ts # Literal-only unit conversion (convertLiteral)
    └── unitConvert.ts # Unit conversion