# ParaShape

> Parametric 3D modeling for SketchUp and the browser. Build configurable, parameter-driven components (cabinets, shelving, framing, furniture) that you drop into a SketchUp model or author in a web app. Every model is a small JSON definition — change a parameter and the geometry rebuilds; share it by URL, embed it, or fork it.

ParaShape's primary users are SketchUp users (architects, interior and furniture designers), not developers. Geometry is built from a profile→extrude / surface→mesh pipeline rather than fixed primitives.

## App

- [Model workspace](https://parashape.com/model): the full workspace — model catalog, 3D viewport, and a node panel editing the same expression-first JSON directly. `/model/ID` opens a saved model (immutable uuid, no slug); guests view/orbit/export freely, Save/Clone/Translate/Embed are auth-gated actions in the panel menu. No install; create, save, and share from any device.
- [SketchUp host](https://parashape.com/sketchup/v1/): the plugin UI. Place a parametric component into your model; its JSON is stored inside the SketchUp component so it stays editable in the .skp. Plugin loads this URL directly (online-only, no offline bundle).
- [Configurator](https://parashape.com/configurator/ID): same catalog + viewport layout as the workspace, but the right panel is a lean ConfiguratorPanel — visible params only (slider/checkbox/color), no node editing, no Save/Clone/Translate.
- [B2B configurator embed](https://parashape.com/embed/ID): origin-gated iframe page — viewport (left) + ConfiguratorPanel (right, visible params only), no catalog. Checks `document.referrer` against `allowed_origins` when loaded in an iframe (direct access always allowed). Manage via **Embed settings…** in the model workspace header menu (owner only). API: `GET /api/embed-origins?id=:id` → `{ origins: string[] | null }` (null = unrestricted, [] = disabled); `POST /api/embed-origins` body `{ id, origins }` saves the whitelist. Embed snippet: `<iframe src="…/embed/{id}" …>`.

## Docs

- [Docs](https://parashape.com/docs): overview, getting started, and concepts.
- [Node registry](https://parashape.com/docs/nodes): every method by lane — value-lane methods bind a parameter (inputs, live in the model's `parameters` header), entity-lane methods are producers (create geometry/scene entities, concat into the stream) or transforms (a local op on the stream so far — map / multiply / reduce / structural; `method` is globally unique, domain-prefixed `curve*`/`face*`/`edge*`/`group*`/`solid*`; the registry-derived namespace names the scene-entity kind it acts on, and it filters itself out when the entities currently in the stream don't fit).

## Model format (JSON v21 — operations model)

- A model is `{ id?, title, camera?, parameters?: NodeJSON[], operations?: NodeJSON[], unit }` — TWO node arrays: `parameters` (header — named VALUE bindings, order display-only) and `operations` (body — THE graph, one flat fold, order = execution order). Omit either array when empty. Args are expression strings (`"600"`, `"width - thickness"`).
- ONE recursive node shape, `NodeJSON = OperationJSON | ContainerJSON`, discriminated by which REQUIRED field is present: **operation** `{ key?, label?, enabled?, method, args? }` runs one registry method against the fold state (`key` names the stream AFTER it); **container** `{ key?, label?, enabled?, operations: NodeJSON[] }` runs its OWN `operations[]` from an empty stream and concats its result into the parent (`key` names its OWN fold result). No `nodeType` field, no `id` per node, no `generators[]`/`modifiers[]` split, no `method:"container"`/`method:"group"` — a container is grammar, not a registry method.
- The fold: `operations[]` is ONE flat list executed top-down over a stream starting `[]`. A **producer** method (`polyline`/`rectangle`/`extrude`/`clone`/`placeModel`/…) CONCATS: `stream = [...stream, ...create(args)]`. A **transform** method (`move`/`curveSelfUnion`/`curveExtrude`/`applyMaterial`/…) PROCESSES the stream: `stream = compute(stream, args)`. A container runs its own fold from empty and its result concats in like a producer — one nesting meaning only. `enabled` falsy on an operation bypasses it (pass-through, same identity); falsy on a container drops its whole contribution. Every registry method declares `return: "value" | "curveEntity" | "faceEntity" | "pointEntity" | "entity"` — `"value"` methods (length/number/boolean/text/color/angle/function/loadModel/loadFont/loadImage/createMaterial/createLayer) live ONLY in `parameters`; every other `return` kind lives ONLY in `operations`. Pure math is written inline in expressions via PascalCase namespaces (`Point`/`Vector`/`Plane`/`Axis`/`Curve`/`Surface`/`Face`) — there is no computation node.
- Two layers: a COMPUTATION layer (expression namespaces Point / Vector / Curve, where all math lives — value→value, transient, no render; AI writes it as text) and a SCENE-ENTITY layer (the thin render/export boundary — operations produce/transform entities that flow to the renderer: Three.js / SketchUp). Decision rule for any feature: produces a VALUE → expression; produces a RENDERABLE ENTITY → operation. The scene-entity set = the renderer primitive set (wire / filled-region / point). Naming mirrors this split: the value layer keeps bare PascalCase namespaces (`Point`, `Vector`, `Curve`, `Face`) — pure values, the function substrate; the scene-entity layer uses camelCase `*Entity` namespaces (`pointEntity`, `curveEntity`, `faceEntity`) — producers that materialize/render. So a value (`Curve.length`, transient) is never confused with a bound, rendered scene entity (`curveEntity`).
- Scene entities (4 kinds — 3 geometric + group): `Curve` (1D wire / closed loop), `Face` (flat 3-D polygon region, holes via extra loops), `Point` (position marker). An entity is `{ id, geometry, visible?, layer?, material?, label?, sourceKey? }` with NO `type` tag — its kind is sniffed from the `geometry` shape (point=[x,y,z], curve=NurbsCurveJSON, face={loops,uvMatrix}). A 4th kind `groupEntity` = `{ id, definition, transformation, material?, layer?, name?, visible? }` — one placement of a shared GroupDefinition (no `geometry`; kind = has `definition`), see Instances below. There is no Block entity — a solid is still `Face[]` (a box = 6 faces). NURBS is NOT a scene entity (it tessellates anyway, so it belongs to computation, not the scene); the shapemetry kernel still uses NURBS internally. Face[] → SketchUp faces is a 1:1 lossless export.
- Producer return kinds: `curveEntity` (polyline/spline/rectangle/polygon/arcCenterStartEnd/arcThreePoints/arcTangentEnd/circle/ellipseArc/cubicBezier/quadraticBezier/nurbsCurve/textCurve); `faceEntity` (extrude/sweep + the curved producers loft/revolve/patchFromCurve/patchFromCorners — build a kernel NurbsSurface internally then tessellate to per-triangle Faces; extrude/loft/etc. accept a closed curve directly and fill it into a Face internally, no separate fill step); `entity` producers (clone/addMesh/placeModel). Transforms (globally unique `method`, any position in an `operations[]` list after the entities they need exist): Instance — `move`/`rotate`/`resize`/`applyMaterial`/`applyLayer`/`visible`/`name`/`arrayLinear`/`arrayRadial`/`arrayCurve`/`arrayDistances`/`mirror`; CurveEntity — `curveSplit`/`curveFillet`/`curveChamfer`/`curveOffset`/`curveThicken`/`curveReverse`/`curveExtrude`/`curveUnion`/`curveSubtract`/`curveIntersect`/`curveSelfUnion`; FaceEntity — `solidUnion`/`solidSubtract`/`solidIntersect`/`solidSelfUnion`/`faceExtrude`/`faceOffset`/`edgeFillet`/`edgeChamfer`/`faceReverse`/`faceLattice`; Group — `groupExplode`/`looseToGroup`/`makeGroup`. The fold is a PIPELINE — entity kind may change mid-fold (`curveExtrude` turns Curve[] into a Face[] solid in place).
- Pipelines: `curveEntity → extrude` (solid), `curveEntity → revolve / loft / sweep` (curved, tessellated to Faces), `faceEntity → solidUnion/solidSubtract/solidIntersect (3D mesh CSG on Face[]) / edgeFillet/edgeChamfer`; `curveEntity → curveUnion/curveSubtract/curveIntersect` (2D region boolean on closed curves — a separate method, not the same one). There are no primitive solids (box/cylinder/sphere/cone) — build from profiles.
- Value model (one lane): an operation's value is a plain `EntityJSON[]` — the stream AFTER it; a container's value is its own fold result — both verbatim, steps applied in LISTED order. A "copy" is a nested `groupEntity` referencing a shared GroupDefinition (SketchUp component semantics) — instancing lives in that structure, not in a separate placements lane. Transforms (`move`/`rotate`; `arrayLinear`/`arrayRadial`/`arrayCurve`/`arrayDistances`/`mirror`) map over ALL entities INCLUDING nested groups: a transform composes onto a group's placement (cheap); an array over a group copies the wrapper (shared definition = instancing); an array over raw geometry bakes real transformed copies. `array*` take `copies` = copies ADDED. Props (`applyMaterial`/`applyLayer`/`visible`/`name`) stamp each entity or group wrapper (a `(entity, index) =>` callback varies per copy). Renderer split derives from the value shape: ≥2 groupEntity sharing ONE definition → instanced render; anything else → baked. Material/layer declarations (`return:"value"` header nodes with `method:"createMaterial"`/`"createLayer"`) register named resources; no render output.
- `groupExplode` (registry-derived namespace `Group`) dissolves the NESTED groups inside a node's content — a placed sub-model (`placeModel`) or a `clone` — into raw geometry (SketchUp Explode); the node itself stays a group. `nested` (default true) dissolves recursively; false = one level.
- Grouping: wrap a producer + its following transforms in a container (`{ key, operations: [...] }`) to travel as one authorable unit (one builder-panel card, one render slice, one SketchUp export name) — this is what used to be "a generator with its modifiers array"; a bare single-step operation entry with its own `key` is fine standalone.

## Registry reference (auto-generated)

The lists below are generated from the SSOT registries (`packages/parametric/src/schema/types.ts`, `packages/parametric/src/nodesRegistry/catalog.ts`, `schema.ts`) by `scripts/gen-reference.mjs`. They are the canonical, drift-free enumeration of every type, node, and the model TypeScript contract. The prose above is hand-written; the blocks below mirror the registries exactly.

### Types

<!-- AUTOGEN:types -->
| Type | Kind | Shape | Note |
|---|---|---|---|
| `curveEntity` | sceneEntity | `{ id: string, geometry: NurbsCurveJSON, visible?: boolean, layer?: string, material?: string, label?: string, sourceKey?: string }` | 1D wire — line / arc / bezier / nurbs curve. NO type tag — kind is sniffed from the geometry shape (curve geometry = NurbsCurveJSON, has controlPoints). |
| `faceEntity` | sceneEntity | `{ id: string, geometry: { loops: [x,y,z][][], uvMatrix?: number[16] }, visible?: boolean, layer?: string, material?: string, label?: string, sourceKey?: string }` | Flat bounded region; a solid is faceEntity[]. NO type tag — kind is sniffed from the geometry shape (face geometry has loops). loops = 3D world polygons, outer loop first then holes; uvMatrix = row-major 4×4 plane→world frame for UV / 2D projection. |
| `pointEntity` | sceneEntity | `{ id: string, geometry: [x,y,z], visible?: boolean, layer?: string, material?: string, label?: string, sourceKey?: string }` | Point marker — render-only, from the pointEntity generator. NO type tag — kind is sniffed from the geometry shape (point geometry = [x,y,z]). |
| `groupEntity` | sceneEntity | `{ id: string, definition: string, transformation: number[16], material?: string, layer?: string, name?: string, visible?: boolean }` | ONE placement of a GroupDefinition (SketchUp component model). `definition` = id of the shared content `{ id: string, entities: EntityJSON[] }` in the model's runtime definitions map — child entities stored ONCE, the definition itself is NOT a scene entity. `transformation` = column-major 4×4 (translation at indices 12,13,14). A node's value is groupEntity[]: N placements, 1 shared definition. Kind = has `definition` (no `geometry`). |
| `entity` | namespace | `(curveEntity\|faceEntity\|pointEntity\|groupEntity)[]` | Generic ops over any scene entity (move/rotate/array/mirror…). An entity has NO type tag — kind is discriminated by its geometry shape (a groupEntity by its `definition` field). |
| `material` | namespace | `MaterialJSON` | Material definition |
| `layer` | namespace | `LayerJSON` | Layer definition |
| `number` | value | `number` | Unitless number |
| `length` | value | `number (mm)` | Distance (mm) |
| `angle` | value | `number (deg)` | Degrees |
| `binary` | value | `0 \| 1` | 0 or 1 — multiply with a dimension to collapse it |
| `string` | value | `string` | Text (single-quoted literal) |
| `color` | value | `#rrggbb` | #rrggbb hex string |
| `vector` | value | `[x,y,z]` | Direction [x, y, z] or [x, y] (z defaults to 0) |
| `point` | value | `[x,y,z]` | Position [x, y, z] or [x, y] (z defaults to 0) |
| `plane` | value | `{point:[x,y,z],normal:[nx,ny,nz]}` | Infinite plane: a point on the plane + unit normal. Build via Plane.fromPointNormal. |
| `axis` | value | `{origin:[x,y,z],direction:[dx,dy,dz]}` | Directed half-line: origin + unit direction (magnitude dropped). Build via Axis.fromPointDirection / Axis.fromTwoPoints. |
| `curve` | value | `NurbsCurveJSON { degree, knots, controlPoints, weights }` | Curve geometry value (NURBS) — the geometry of a curveEntity. Use with Curve.* functions; a curveEntity arg unwraps to this. |
| `face` | value | `{ loops: [x,y,z][][], uvMatrix?: number[16] }` | Face geometry value — the geometry of a faceEntity. Use with Face.* functions; a faceEntity arg unwraps to this. |
| `surface` | value | `NurbsSurfaceJSON { degreeU, degreeV, knotsU, knotsV, controlPoints, weights }` | NURBS surface value (computation only — not a scene entity). Use with Surface.* functions; a curved generator tessellates one to faceEntity[]. |
| `function` | value | `(args) => value` | Lambda expression |
| `model` | value | `string (model ref)` | Model reference |
| `object` | value | `object` | Parameter group |
| `group` | value | `object` | Visual group |
| `area` | value | `number` | Area unit |
| `volume` | value | `number` | Volume unit |
| `mass` | value | `number` | Mass unit |
| `currency` | value | `number` | Currency |
| `font` | value | `FontData` | Opentype-parsed font object (fetch + parse happens async in Phase 1 via store.loadFonts). Returned by loadFont parameter; consumed synchronously by text generator's font arg. |
| `image` | value | `string` | Image reference — URL or data URI, returned by loadImage parameter, consumed by material texture args. |
| `url` | value | `string (uri)` | Asset URI — bare-id, https://, or data: URI. Used as the input field value for loadModel / loadFont / loadImage parameters. |
| `fn` | value | `Function` | Callback function: (entity, index) => value. Accepted alongside a static value for per-entity variation. |
| `keyValue` | value | `{key:string,value:unknown}` | Key-value override pair. Used by a node's dynamic args (DynamicArgDef) to target one specific parameter inside a referenced value by name — e.g. loadModel's replace* args drive a promoted parameter of the loaded sub-model. |
<!-- /AUTOGEN:types -->

### Nodes

<!-- AUTOGEN:nodes -->
### Producers — by `return` (the entity kind produced; concat into the stream)

#### `curveEntity`
- **`curveEntity.polyline`** — Polyline
  - `0` : point[] — Ordered vertices [x,y,z] (z optional, defaults 0).
  - `1` : binary — true closes the loop back to the first point; false leaves it open.
- **`curveEntity.spline`** — Spline
  - `0` : point[] — Control points [x,y,z] the smooth curve passes through/near.
  - `1` : number — Curve smoothness: 1 = polyline, 2 = quadratic, 3 = cubic (most common).
- **`curveEntity.rectangle`** — Rectangle
  - `0` : point — One corner of the rectangle.
  - `1` : point — Opposite corner. The axis with the smallest difference from Point 1 becomes the rectangle's plane (XY/XZ/YZ) — no separate rotate needed to place it on a different plane.
- **`curveEntity.polygon`** — Polygon
  - `0` : point — Polygon center [x,y] in the XY plane.
  - `1` : length — Circumradius — distance from center to each vertex.
  - `2` : number — Number of edges, minimum 3.
- **`curveEntity.arcCenterStartEnd`** — Arc (Center)
  - `0` : point — Arc center [x,y]; the radius = distance from center to start.
  - `1` : point — Where the arc begins; sets the radius.
  - `2` : point — Direction the arc sweeps toward (snapped onto the radius).
- **`curveEntity.arcThreePoints`** — Arc (3 Points)
  - `0` : point — First endpoint the arc passes through.
  - `1` : point — Point on the arc between start and end (defines the bulge).
  - `2` : point — Last endpoint the arc passes through.
- **`curveEntity.arcTangentEnd`** — Arc (Tangent)
  - `0` : axis — Start point + leaving tangent direction, as an axis (magnitude irrelevant).
  - `1` : point — Where the arc ends.
- **`curveEntity.circle`** — Circle
  - `0` : point — Circle center [x,y] in the XY plane.
  - `1` : length — Circle radius.
- **`curveEntity.ellipseArc`** — Ellipse Arc
  - `0` : point — Ellipse center [x,y].
  - `1` : vector — Major-axis vector; its length is the X radius.
  - `2` : vector — Minor-axis vector (perpendicular to xAxis); its length is the Y radius.
  - `3` : angle — Sweep in degrees: 360 = full closed ellipse, under 360 = open arc.
- **`curveEntity.cubicBezier`** — Cubic Bezier
  - `0` : point — Start point (on curve).
  - `1` : point — First tangent control point.
  - `2` : point — Second tangent control point.
  - `3` : point — End point (on curve).
- **`curveEntity.quadraticBezier`** — Quadratic Bezier
  - `0` : point — Start point (on curve).
  - `1` : point — Tangent control (pulled toward, not on curve).
  - `2` : point — End point (on curve).
- **`curveEntity.nurbsCurve`** — NURBS Curve
  - `0` : point[] — Control points [x,y,z] of the hull; the curve is pulled toward them, not through.
  - `1` : number — Polynomial degree (clamped to points.length-1): 1 = polyline, 3 = smooth cubic.
  - `2` : number[] — Knot vector (length = points.length + degree + 1, non-decreasing). Empty = auto clamped-uniform.
  - `3` : number[] — Per-point weight, > 0 (length = points.length). Empty = uniform 1; higher pulls the curve toward that point.
- **`curveEntity.textCurve`** — Text
  - `0` : string — The string to render as outline curves; single-quote the literal.
  - `1` : font — Font reference; leave '' to use the built-in fallback font.
  - `2` : length — Cap height of the glyphs in model units.

#### `entity`
- **`entity.clone`** — Clone
  - `0` : entity[] — Node to copy — returns an independent deep copy with fresh ids.
- **`entity.addMesh`** — Mesh
  - `0` : faceEntity[] — Baked face array literal — emits an independent, transformable copy (fresh ids).
- **`entity.placeModel`** — Place Model
  - `0` : model — Model ID to place — emits an independent placement with fresh ids.

#### `faceEntity`
- **`faceEntity.extrude`** — Extrude
  - `0` : point[] | curveEntity[] | faceEntity[] — Closed loop becomes a solid with caps; open becomes walls. Accepts points, curves, or faces.
  - `1` : length — Extrusion distance along the profile's normal.
  - `2` : binary — 1 = closed profiles get top/bottom caps (a solid); 0 = walls only (open shell).
- **`faceEntity.sweep`** — Sweep
  - `0` : curveEntity — Path the profile is swept along (open or closed curve).
  - `1` : curveEntity — Closed cross-section curve carried along the path; yields a solid tube.
  - `2` : binary — Close the two ends of the swept tube (false = open duct).
- **`faceEntity.loft`** — Loft
  - `0` : curveEntity[] — Ordered cross-section curves the skin passes through (2 or more).
  - `1` : number — Smoothness across sections: 1 = straight (ruled) between curves, 3 = smooth.
- **`faceEntity.revolve`** — Revolve
  - `0` : curveEntity[] — Profile curve(s) spun about the axis; a closed profile yields a solid.
  - `1` : axis — Revolution axis (origin on the axis, direction = spin axis).
  - `2` : angle — Sweep in degrees: 360 = full solid, under 360 = partial.
- **`faceEntity.patchFromCurve`** — Patch From Curve
  - `0` : curveEntity[] — Boundary curves enclosing the region to fill with a smooth surface.
- **`faceEntity.patchFromCorners`** — Patch From Corners
  - `0` : point — First corner [x,y,z]; corners wind in order 0→1→2→3.
  - `1` : point — Second corner [x,y,z].
  - `2` : point — Third corner [x,y,z], diagonal from corner 0.
  - `3` : point — Fourth corner [x,y,z].

#### `pointEntity`
- **`pointEntity.pointEntity`** — Render Points
  - `0` : point[] — Marker positions [x,y,z] to visualize (render-only, not construction geometry).

### Transforms — by `namespace` (the entity kind acted on; process the stream)

#### `CurveEntity`
- **`curveOffset`** — Offset Curve *(namespace: CurveEntity, shape: reduce)*
  - `0` : length — Offset amount: positive = outward, negative = inward.
- **`curveThicken`** — Thicken Curve *(namespace: CurveEntity, shape: reduce)*
  - `0` : length — Strip width (the curve is offset half this to each side).
  - `1` : string — How outer corners are joined: 'round' (arc), 'miter' (sharp point), 'square' (clipped).
  - `2` : string — How open ends are capped: 'round' (semicircle), 'square' (half-width), 'butt' (flush).
- **`curveUnion`** — Curve Union *(namespace: CurveEntity, shape: reduce)*
  - `0` : curveEntity — The closed curve to merge with this one (2D boolean).
- **`curveSubtract`** — Curve Subtract *(namespace: CurveEntity, shape: reduce)*
  - `0` : curveEntity — The closed curve to cut away from this one (2D boolean).
- **`curveIntersect`** — Curve Intersect *(namespace: CurveEntity, shape: reduce)*
  - `0` : curveEntity — The closed curve to keep only the overlap with (2D boolean).
- **`curveSelfUnion`** — Curve Self Union *(namespace: CurveEntity, shape: reduce)*
  - *(no args)*
- **`curveExtrude`** — Extrude *(namespace: CurveEntity, shape: multiply)*
  - `0` : length — Extrusion distance along the profile's normal.
  - `1` : binary — 1 = closed profiles get top/bottom caps (a solid); 0 = walls only (open shell).
- **`curveReverse`** — Reverse *(namespace: CurveEntity, shape: map)*
  - `0` : binary — true flips direction (curve order / face normal); false leaves it.
- **`curveSplit`** — Curve Split *(namespace: CurveEntity, shape: multiply)*
  - `0` : number — Normalized split position from start (0) to end (1).
- **`curveFillet`** — Curve Fillet *(namespace: CurveEntity, shape: map)*
  - `0` : length — Arc radius rounding each selected corner (curved).
  - `1` : function — Predicate over a corner vertex and its index selecting which to round; default = all.
- **`curveChamfer`** — Curve Chamfer *(namespace: CurveEntity, shape: map)*
  - `0` : length — Straight setback from each selected corner (flat cut, not an arc).
  - `1` : function — Predicate over a corner vertex and its index selecting which to cut; default = all.

#### `FaceEntity`
- **`solidUnion`** — Solid Union *(namespace: FaceEntity, shape: reduce)*
  - `0` : faceEntity[] — The closed solid (Face[]) to fuse with this one (3D CSG).
- **`solidSubtract`** — Solid Subtract *(namespace: FaceEntity, shape: reduce)*
  - `0` : faceEntity[] — The closed solid (Face[]) to carve out of this one (3D CSG).
- **`solidIntersect`** — Solid Intersect *(namespace: FaceEntity, shape: reduce)*
  - `0` : faceEntity[] — The closed solid (Face[]); keeps only the volume shared by both (3D CSG).
- **`solidSelfUnion`** — Solid Self Union *(namespace: FaceEntity, shape: reduce)*
  - *(no args)*
- **`faceLattice`** — Lattice *(namespace: FaceEntity, shape: map)*
  - `0` : length — Strut/wall thickness of the lattice shell.
  - `1` : binary — Close the open border edges of the lattice with caps.
- **`faceExtrude`** — Face Extrude *(namespace: FaceEntity, shape: map)*
  - `0` : length — Distance to push the selected faces along their normal (negative = inward).
  - `1` : function — Predicate over a face's points and normal selecting which faces to push; default = all.
- **`edgeFillet`** — Edge Fillet *(namespace: FaceEntity, shape: map)*
  - `0` : function — Predicate over an edge's two endpoints selecting which edges to round; default = all.
  - `1` : length — Rolling-ball arc radius of the rounded edge (curved).
  - `2` : number — Number of facets across the arc; higher = smoother.
- **`edgeChamfer`** — Edge Chamfer *(namespace: FaceEntity, shape: map)*
  - `0` : function — Predicate over an edge's two endpoints selecting which edges to cut; default = all.
  - `1` : length — Flat-cut setback from the edge (a straight 45°-style bevel, not an arc).
- **`faceReverse`** — Reverse *(namespace: FaceEntity, shape: map)*
  - `0` : binary — true flips direction (curve order / face normal); false leaves it.
- **`faceOffset`** — Offset Face *(namespace: FaceEntity, shape: map)*
  - `0` : length — Inset (positive) or outset (negative) distance.

#### `Instance`
- **`arrayLinear`** — Linear Array *(namespace: Instance, shape: multiply)*
  - `0` : vector — Per-copy step — magnitude IS the spacing (unlike Array Along Distances, where direction is normalized).
  - `1` : number — Copies to add — the original stays, so 1 duplicates once.
- **`arrayRadial`** — Radial Array *(namespace: Instance, shape: multiply)*
  - `0` : axis — Rotation axis: origin = pivot point, direction = spin axis.
  - `1` : number — Copies to add around the axis — original + copies spaced evenly over 360°.
- **`arrayCurve`** — Array Along Curve *(namespace: Instance, shape: multiply)*
  - `0` : curveEntity — Path curve the copies are distributed along.
  - `1` : number — Copies to add along the curve — original at the start, spaced evenly.
  - `2` : angle — Extra rotation in degrees applied to each copy about the curve tangent.
- **`arrayDistances`** — Array by Distances *(namespace: Instance, shape: multiply)*
  - `0` : vector — Direction to array along — magnitude ignored, see Distances for spacing.
  - `1` : length[] — Gap after each copy, in order, along Direction. Copy count = number of distances (a partition — no separate Copies arg).
- **`mirror`** — Mirror *(namespace: Instance, shape: multiply)*
  - `0` : plane — Mirror plane (point on plane + normal).
  - `1` : binary — 1 keeps the original and adds the reflection; 0 flips in place.
- **`move`** — Move *(namespace: Instance, shape: map)*
  - `0` : vector — Displacement to apply.
- **`rotate`** — Rotate *(namespace: Instance, shape: map)*
  - `0` : axis — Rotation axis (origin = pivot point, direction = axis; magnitude irrelevant).
  - `1` : angle | fn — Rotation angle in degrees (CCW about the axis), or a callback (entity, index) => number, per entity.
- **`resize`** — Resize *(namespace: Instance, shape: map)*
  - `0` : length | fn — Target width along X, or a callback (entity, index) => number, per entity.
  - `1` : length | fn — Target depth along Y, or a callback (entity, index) => number, per entity.
  - `2` : length | fn — Target height along Z, or a callback (entity, index) => number, per entity.
- **`applyMaterial`** — Material *(namespace: Instance, shape: map)*
  - `0` : string | fn — Material name to assign (single-quote literals), or a callback (entity, index) => string, per entity.
- **`applyLayer`** — Layer *(namespace: Instance, shape: map)*
  - `0` : string | fn — Layer name to assign (single-quote literals), or a callback (entity, index) => string, per entity.
- **`visible`** — Visible *(namespace: Instance, shape: map)*
  - `0` : binary | fn — true shows, false hides the entities; or a callback (entity, index) => boolean, per entity.
- **`name`** — Name *(namespace: Instance, shape: map)*
  - `0` : string | fn — Display/export name tag (single-quote literals), or a callback (entity, index) => string, per entity.

#### `Group`
- **`groupExplode`** — Explode *(namespace: Group, shape: structural)*
  - `0` : binary — Dissolve this node's nested groups (a placed sub-model / clone) into raw geometry — SketchUp Explode. 1 = recursive; 0 = one level.
- **`looseToGroup`** — Loose to Groups *(namespace: Group, shape: structural)*
  - *(no args)*
- **`makeGroup`** — Make Group *(namespace: Group, shape: structural)*
  - *(no args)*

### Parameters — value bindings (header lane)

#### `angle`
- **`angle.angle`** — Angle
  - `0` : angle

#### `boolean`
- **`boolean.boolean`** — Boolean
  - `0` : binary

#### `color`
- **`color.color`** — Color
  - `0` : color

#### `createLayer`
- **`createLayer.createLayer`** — Layer
  - `0` : string — Layer name, referenced by the layer modifier. Single-quote the literal.

#### `createMaterial`
- **`createMaterial.createMaterial`** — Material
  - `0` : string — Material name, referenced by the material modifier. Single-quote the literal.
  - `1` : color — Base color as a hex string (#rrggbb).
  - `2` : number — 0 = fully transparent, 1 = opaque.
  - `3` : image — Image file (data URL or asset URL) tiled across the surface; '' = none.
  - `4` : number — Blend texture and baseColor: 0 = texture only, 1 = solid baseColor.

#### `length`
- **`length.length`** — Length
  - `0` : length

#### `loadModel`
- **`loadModel.loadModel`** — Load Model
  - `0` : model — Sub-model reference (platform id, URL, or data: URI). Loaded once and cached; place copies with the placeModel generator.

#### `number`
- **`number.number`** — Number
  - `0` : number

#### `text`
- **`text.text`** — Text
  - `0` : string
<!-- /AUTOGEN:nodes -->

### Model schema (TypeScript)

<!-- AUTOGEN:schema -->
```ts
type expression = string // any JS expression: arithmetic, parameter key refs, Math.* calls, ternary, arrow functions; literal text single-quoted ('Oak')

type ValueMethod = "angle" | "arrayLength" | "boolean" | "color" | "createLayer" | "createMaterial" | "function" | "length" | "loadFont" | "loadImage" | "loadModel" | "number" | "text"

type EntityMethod = "addMesh" | "applyLayer" | "applyMaterial" | "arcCenterStartEnd" | "arcTangentEnd" | "arcThreePoints" | "arrayCurve" | "arrayDistances" | "arrayLinear" | "arrayRadial" | "circle" | "clone" | "cubicBezier" | "curveChamfer" | "curveExtrude" | "curveFillet" | "curveIntersect" | "curveOffset" | "curveReverse" | "curveSelfUnion" | "curveSplit" | "curveSubtract" | "curveThicken" | "curveUnion" | "edgeChamfer" | "edgeFillet" | "ellipseArc" | "extrude" | "faceExtrude" | "faceLattice" | "faceOffset" | "faceReverse" | "groupExplode" | "loft" | "looseToGroup" | "makeGroup" | "mirror" | "move" | "name" | "nurbsCurve" | "patchFromCorners" | "patchFromCurve" | "placeModel" | "pointEntity" | "polygon" | "polyline" | "quadraticBezier" | "rectangle" | "resize" | "revolve" | "rotate" | "solidIntersect" | "solidSelfUnion" | "solidSubtract" | "solidUnion" | "spline" | "sweep" | "textCurve" | "visible"

type Method = ValueMethod | EntityMethod

type ModelJSON = {
    id?: string
    title: string
    camera?: CameraJSON
    parameters?: NodeJSON[]
    operations?: NodeJSON[]
    unit: {
        length: "mm" | "cm" | "m" | "in" | "ft" /* default: "mm" */
        area?: "mm2" | "cm2" | "m2" | "in2" | "ft2"
        volume?: "mm3" | "cm3" | "m3" | "in3" | "ft3" | "L"
        mass?: "mg" | "g" | "kg" | "lb" | "oz"
    } /* default: {"length":"mm"} */
}

type CameraJSON = {
    type?: "perspective" | "orthographic"
    position: unknown[]
    target: unknown[]
    zoom?: number
}

type NodeJSON = OperationJSON | ContainerJSON

type OperationJSON = {
    key?: string
    label?: expression
    enabled?: expression
    method: Method
    args?: ArgumentJSON[]
}

type ContainerJSON = {
    key?: string
    label?: expression
    enabled?: expression
    operations: (OperationJSON | ContainerJSON)[]
}

type ArgumentJSON = {
    key: string
    input: string
    label?: string
    min?: expression
    max?: expression
    step?: expression
    options?: OptionJSON[]
}

type OptionJSON = {
    label: string
    input: expression
}

// JS globals in expression scope — using as node key shadows the global
const JS_RESERVED = ["Math","Number","String","Boolean","Array","Object","isNaN","parseFloat","parseInt"] as const

// ECMAScript reserved words & special identifiers — forbidden as node keys
const JS_KEYWORDS = ["break","case","catch","continue","debugger","default","delete","do","else","finally","for","function","if","in","instanceof","new","return","switch","this","throw","try","typeof","var","void","while","with","class","const","enum","export","extends","import","let","static","super","yield","async","await","implements","interface","package","private","protected","public","of","null","true","false","undefined","NaN","Infinity","arguments","eval"] as const
```
<!-- /AUTOGEN:schema -->