@mulmoclaude/shapescript-plugin 2.0.0 → 2.3.0

package/dist/shapescript/parser.d.ts

@@ -3,6 +3,18 @@ export declare class Parser {
     /** Whether the expression being parsed is one value of a whitespace-separated
      *  list. See `withValueList`. */
     private valueList;
+    /** Names a bare call may use (`max 0 1`, `sqrt 9`): the built-ins plus every
+     *  `define name(…)` seen so far, minus names a plain `define` shadows. Lexical
+     *  and unscoped — a shadow inside a block outlives the block, which only
+     *  matters to a script that reuses a function's name for a number. */
+    private callable;
+    /** Custom block names, so a user-defined `light` is still invoked rather
+     *  than skipped as the upstream light source. */
+    private blocks;
+    /** Names a plain `define` gave a value, so a keyword reused as a symbol
+     *  (`define hull (0.2 0.2 0.2)` then `color hull`) reads as that symbol
+     *  rather than as the shape or builder it spells. */
+    private values;
     private tokens;
     private pos;
     constructor(tokens: Token[]);
@@ -14,18 +26,32 @@ export declare class Parser {
     private expectIdentifier;
     private skipNewlines;
     private parseExpression;
+    /** `a to b [step s]` after a full expression, or `range step s` to re-step a
+     *  range held in a symbol. Lowest precedence of all, so `1 to n - 1` runs to
+     *  `n - 1`; only a whole expression (minPrec 0) can become a range. */
+    private parseRangeTail;
     private parsePrimary;
     /** The body of a `( … )`, with the opening paren already consumed.
      *
      *  Both a grouped expression and a space- or comma-separated tuple live here,
      *  so its elements are read as a VALUE LIST: `(1 +2 +3)` is three components,
      *  the same as `1 +2 +3` written without the parens. */
+    /** Line breaks inside parentheses carry no meaning (literals.md): a tuple of
+     *  tuples may be laid out one row per line, and an expression may continue
+     *  on the next line. Dropping the NEWLINE tokens up to the matching `)` lets
+     *  the one-line rules decide, with the break counted as whitespace. */
+    private stripNewlinesInParens;
     private parseParenthesized;
     /** `(1, 2, 3)` — a trailing comma before the `)` ends the list. */
     private parseCommaSeparated;
-    /** `(1 2 3)` — components held apart by nothing but whitespace. */
+    /** `(1 2 3)` — components held apart by whitespace, line breaks included. */
     private parseSpaceSeparated;
     private parseAtom;
+    /** `for [name in] iterable { expression }` — the tuple of every result. */
+    private parseForExpression;
+    /** `if condition { expression } else { expression }`. */
+    private parseIfExpression;
+    private parseBracedExpression;
     private getPrecedence;
     private tokenTypeToOperator;
     private parseVectorOrExpression;
@@ -34,19 +60,53 @@ export declare class Parser {
     private parseValueList;
     private parseProperties;
     private parseBlockContents;
+    /** Run `parse` with the callable and block name sets scoped to it, so a
+     *  `define max 5` inside a block stops shadowing the built-in at the
+     *  block's closing brace — the parser-side mirror of the runtime scope. */
+    private scoped;
     private parseBlock;
     private parseShape;
     private parseCSG;
+    /** `for [name in] <range or tuple> { … }`. The range is an ordinary
+     *  expression (`1 to n step 2`, or a symbol holding one), so `for 1 to 5`
+     *  and `for i in loops` read the same way. */
     private parseForLoop;
+    /** A keyword that a binding in scope has claimed as a value — a shape,
+     *  builder or control-flow word used as a parameter or loop variable.
+     *  Property and transform commands (`size`, `color`, `scale`, …) are not
+     *  included: `define size 1 2` must not turn a later `size` command into a
+     *  value, and inside a block they are read as properties anyway. */
+    private isBoundKeyword;
+    /** A name bound in the current scope — loop variable, parameter, option —
+     *  is a value there: not a callable, and not the shape it may spell. */
+    private bindName;
+    private parseLoopHeader;
     private parseIf;
     private parseSwitch;
     private parseDefine;
+    /** An upstream command this renderer lacks, named instead of failing on
+     *  the brace that follows it. */
+    private refuseUnsupported;
+    /** Whether `token` opens a statement rather than an expression — used where
+     *  either may appear, such as a function body. */
+    private startsStatement;
+    /** The body holds statements — `define`s, and shapes the function builds —
+     *  and may end in the expression it returns. A function with no result
+     *  expression returns what its statements built. */
+    private parseFunctionDefine;
     private parseDetail;
     private parseSeed;
     private parseBackground;
-    private parseTexture;
+    /** `opacity` / `metallicity` / `roughness` / `glow` / `texture` / `material`
+     *  as a scoped command. */
+    private parseMaterialCommand;
+    /** `camera { … }` / `light { … }`: the block is consumed and dropped. */
+    private skipIgnoredBlock;
     private parseGroup;
     private parseBuilder;
+    private isAlongOption;
+    /** `along <path or shape>` inside `extrude { … }`: the path the sections are swept along. */
+    private parseAlong;
     /** Run `parse` with the tuple-value break of `isStartOfNewValue` enabled or
      *  suppressed. Whitespace-separated value lists — property values, path
      *  values, the inside of a `( … )` — read ` -1` as the NEXT value; call
@@ -74,12 +134,16 @@ export declare class Parser {
     /** `point x [y]` / `curve x [y]` — absolute coordinates in the path's local
      *  frame, as upstream. Y defaults to 0. */
     private parsePathPoint;
+    /** `arc` or `arc { angle … position … orientation … size … }` inside a path. */
+    private parseArc;
     /** `translate x [y]` / `scale x [y]` inside a path. A lone `translate x`
      *  moves along X only; a lone `scale s` is uniform, recorded by leaving `y`
      *  out rather than by copying the expression (which would evaluate it twice). */
     private parsePathVector;
     private parsePathFor;
     private parseNode;
+    /** `name { option value … }` after the name has been consumed. */
+    private parseCustomShapeCall;
     private refuseStalledToken;
     parse(): SceneNode[];
 }

package/dist/shapescript/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/shapescript/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAEL,SAAS,EA4BV,MAAM,SAAS,CAAC;AA2djB,qBAAa,MAAM;IACjB;qCACiC;IACjC,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,GAAG,CAAK;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAO3B,OAAO,CAAC,EAAE;IAMV,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,eAAe;IAgCvB,OAAO,CAAC,YAAY;IAqBpB;;;;4DAIwD;IACxD,OAAO,CAAC,kBAAkB;IAiB1B,mEAAmE;IACnE,OAAO,CAAC,mBAAmB;IAQ3B,mEAAmE;IACnE,OAAO,CAAC,mBAAmB;IAM3B,OAAO,CAAC,SAAS;IA4FjB,OAAO,CAAC,aAAa;IA0BrB,OAAO,CAAC,mBAAmB;IAmC3B,OAAO,CAAC,uBAAuB;IAI/B;+EAC2E;IAC3E,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,eAAe;IA8DvB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,UAAU;IAkBlB,OAAO,CAAC,QAAQ;IAYhB,OAAO,CAAC,YAAY;IA2EpB,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,WAAW;IA8EnB,OAAO,CAAC,WAAW;IA8DnB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,YAAY;IA8BpB;;;iFAG6E;IAC7E,OAAO,CAAC,aAAa;IAUrB;;gEAE4D;IAC5D,OAAO,CAAC,WAAW;IAKnB;iDAC6C;IAC7C,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,SAAS;IAOjB;;;+CAG2C;IAC3C,OAAO,CAAC,aAAa;IAgBrB;mFAC+E;IAC/E,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,gBAAgB;IA0BxB;+CAC2C;IAC3C,OAAO,CAAC,cAAc;IAOtB;;qFAEiF;IACjF,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,YAAY;IAoBpB,OAAO,CAAC,SAAS;IAqKjB,OAAO,CAAC,kBAAkB;IAM1B,KAAK,IAAI,SAAS,EAAE;CAerB;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAmB5D"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/shapescript/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAEL,SAAS,EAgCV,MAAM,SAAS,CAAC;AA2pBjB,qBAAa,MAAM;IACjB;qCACiC;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B;;;0EAGsE;IACtE,OAAO,CAAC,QAAQ,CAA4C;IAC5D;qDACiD;IACjD,OAAO,CAAC,MAAM,CAAqB;IACnC;;yDAEqD;IACrD,OAAO,CAAC,MAAM,CAAqB;IAEnC,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,GAAG,CAAK;gBAEJ,MAAM,EAAE,KAAK,EAAE;IAO3B,OAAO,CAAC,EAAE;IAMV,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,IAAI;IAIZ,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,YAAY;IAOpB,OAAO,CAAC,eAAe;IAgCvB;;2EAEuE;IACvE,OAAO,CAAC,cAAc;IAiBtB,OAAO,CAAC,YAAY;IAqBpB;;;;4DAIwD;IACxD;;;2EAGuE;IACvE,OAAO,CAAC,qBAAqB;IAiB7B,OAAO,CAAC,kBAAkB;IAuB1B,mEAAmE;IACnE,OAAO,CAAC,mBAAmB;IAU3B,6EAA6E;IAC7E,OAAO,CAAC,mBAAmB;IAQ3B,OAAO,CAAC,SAAS;IAiJjB,2EAA2E;IAC3E,OAAO,CAAC,kBAAkB;IAU1B,yDAAyD;IACzD,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,aAAa;IA2BrB,OAAO,CAAC,mBAAmB;IAqC3B,OAAO,CAAC,uBAAuB;IAI/B;+EAC2E;IAC3E,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,eAAe;IAiFvB,OAAO,CAAC,kBAAkB;IAkB1B;;+EAE2E;IAC3E,OAAO,CAAC,MAAM;IAgBd,OAAO,CAAC,UAAU;IAOlB,OAAO,CAAC,UAAU;IA+BlB,OAAO,CAAC,QAAQ;IAYhB;;kDAE8C;IAC9C,OAAO,CAAC,YAAY;IAWpB;;;;wEAIoE;IACpE,OAAO,CAAC,cAAc;IAItB;4EACwE;IACxE,OAAO,CAAC,QAAQ;IAKhB,OAAO,CAAC,eAAe;IAYvB,OAAO,CAAC,OAAO;IA8Bf,OAAO,CAAC,WAAW;IAgFnB,OAAO,CAAC,WAAW;IA4EnB;qCACiC;IACjC,OAAO,CAAC,iBAAiB;IAMzB;sDACkD;IAClD,OAAO,CAAC,eAAe;IAQvB;;wDAEoD;IACpD,OAAO,CAAC,mBAAmB;IA2C3B,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,SAAS;IAKjB,OAAO,CAAC,eAAe;IAKvB;+BAC2B;IAC3B,OAAO,CAAC,oBAAoB;IAM5B,yEAAyE;IACzE,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,YAAY;IA6CpB,OAAO,CAAC,aAAa;IAIrB,6FAA6F;IAC7F,OAAO,CAAC,UAAU;IAUlB;;;iFAG6E;IAC7E,OAAO,CAAC,aAAa;IAUrB;;gEAE4D;IAC5D,OAAO,CAAC,WAAW;IAcnB;iDAC6C;IAC7C,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,cAAc;IAItB,OAAO,CAAC,SAAS;IAOjB;;;+CAG2C;IAC3C,OAAO,CAAC,aAAa;IAmBrB;mFAC+E;IAC/E,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,gBAAgB;IAgCxB;+CAC2C;IAC3C,OAAO,CAAC,cAAc;IAQtB,gFAAgF;IAChF,OAAO,CAAC,QAAQ;IA6BhB;;qFAEiF;IACjF,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,YAAY;IAWpB,OAAO,CAAC,SAAS;IAsKjB,kEAAkE;IAClE,OAAO,CAAC,oBAAoB;IA2C5B,OAAO,CAAC,kBAAkB;IAM1B,KAAK,IAAI,SAAS,EAAE;CAerB;AAGD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CAmB5D"}

package/dist/shapescript/toThreeJS.d.ts

@@ -1,5 +1,17 @@
 import * as THREE from "three";
 import { SceneNode } from "./types";
+import { RGBA } from "./evaluator";
+/** What a conversion reports besides geometry. Stored on the root group's
+ *  `userData` so both viewers and the tool result can read it. */
+export interface ShapeScriptSceneInfo {
+    /** `background r g b a` from the script's root, when set. */
+    background?: RGBA;
+    /** Commands that were accepted but not rendered (`texture`, `camera`, …). */
+    warnings: string[];
+    /** Every `print`, one line each. */
+    logs: string[];
+}
+export declare function sceneInfoOf(group: THREE.Object3D): ShapeScriptSceneInfo;
 export interface ConversionOptions {
     wireframe?: boolean;
     /** Hard ceiling on the objects one script may produce. See
@@ -43,6 +55,22 @@ export declare class Converter {
     /** When this conversion began, checked against `maxDurationMs` on every node. */
     private readonly startedAt;
     private transformStack;
+    /** > 0 while building a builder's operands, where a bare `path` must be a
+     *  flat mesh for `profileOf`; at the scene level it draws as a line. */
+    private operandDepth;
+    private readonly warnings;
+    private readonly warningSet;
+    private readonly logs;
+    private background;
+    private sceneDepth;
+    /** While set, polygons and shape values produced by statements are
+     *  collected here instead of entering the scene: the body of `mesh { }`,
+     *  and a function body whose result is what it built. */
+    private valueSink;
+    /** Geometries that live on as values (defined shapes, function results,
+     *  `inset` results). Never in the scene themselves — placing one clones it —
+     *  so they are released together once the conversion is over. */
+    private retained;
     constructor(options?: ConversionOptions);
     convert(nodes: SceneNode[]): THREE.Group;
     private get maxNodes();
@@ -70,11 +98,23 @@ export declare class Converter {
      *  one primitive is bounded by `MAX_DETAIL²`, so the allocation that trips the
      *  limit is small, and it is freed before the refusal propagates. */
     private makeMesh;
-    /** Expand a `for … from to to step` range without materialising it first.
-     *  The array used to be built up front, so an absurd bound exhausted memory
-     *  before a single node existed and the budget below never got a turn. */
-    private rangeIterations;
     private convertNode;
+    /** A `path` handed to a builder: the flat face it encloses, which `profileOf`
+     *  reads the perimeter back from. */
+    private convertPathProfile;
+    /** A `detail` inside a path applies to that path alone, as inside any
+     *  block: restore the enclosing level once its points are read. */
+    private withPathDetail;
+    /** A `path` in the scene draws as a stroke, as upstream: `fill` makes a
+     *  face of it, and a builder consumes it. Open paths are allowed here. */
+    private convertPathLine;
+    private lineFromPath;
+    /** Deduplicated and capped: a `texture` inside a 100k-iteration loop must
+     *  not turn the warning list into a transcript, nor the check into a scan. */
+    private warn;
+    /** `background` at the root: a colour is kept for the viewer, a texture
+     *  file cannot be loaded here. */
+    private handleBackground;
     /** Build `group` inside a fresh symbol + transform scope.
      *
      *  The `catch` is not tidiness: nothing downstream can reach a group that was
@@ -95,8 +135,56 @@ export declare class Converter {
      *  the loop is five too many. */
     private addChildren;
     private convertBlock;
+    /** A control-flow body: `for`, `if` and `switch` scope SYMBOLS only. Their
+     *  `translate` / `rotate` / `color` carry on past the closing brace, as
+     *  upstream (scope.md, "Conditional Scope") — a loop that rotates each
+     *  iteration leaves the frame where the last one ended. */
+    private inSymbolScope;
+    /** Wrap a finished geometry in a mesh with the node's material and
+     *  placement. `scaleBySize` is for builders and groups, whose `size` scales
+     *  the result; a primitive's `size` is already in its geometry. */
     private finishMesh;
+    /** Run `build` with the shape's own `detail` / `smoothing` in force, then
+     *  restore the enclosing values. */
+    private withShapeOptions;
     private convertShape;
+    /** Run `build` with produced values going to `sink` rather than the scene. */
+    private captureValues;
+    /** A value a statement produced: collected when a sink is open, otherwise
+     *  a shape is placed in the scene and anything else is an error, as
+     *  upstream's "unused value" is. */
+    private placeValue;
+    private transformedForCapture;
+    private convertExpressionStatement;
+    /** Place a mesh value in the scene with the current material and frame.
+     *  Its own vertex colours win over the material colour, as upstream. */
+    private placeMesh;
+    private placePolygons;
+    /** A geometry that stays alive as a value (a `define`d shape, a function's
+     *  result) counts against the vertex budget for good, since a script can
+     *  keep making them: refuse when it would overflow, then count it. */
+    private chargeRetained;
+    /** Build `nodes` at the origin in a throwaway group, collecting the values
+     *  their statements produced and the geometry of every mesh they built (in
+     *  the group's frame). The group is disposed and its vertex charge refunded;
+     *  what is returned is the caller's to charge. */
+    private buildScratch;
+    /** `mesh { … }`: every polygon its body produces, and every mesh it builds,
+     *  merged into one mesh in the current frame. */
+    private convertMesh;
+    /** `polygon { point … }`: one face from explicit 3D vertices, with `color`
+     *  per vertex, loops and defines, as in a path block. */
+    private polygonValue;
+    /** `point 1 2 3`, or `point v` where `v` is a tuple. */
+    private pointCoordinates;
+    private meshesIn;
+    /** A shape as a value: built at the origin in a scratch group, its meshes
+     *  merged into one geometry the script can read members of and place. A
+     *  polygon block or a function that returned one is that value itself. */
+    private shapeValue;
+    /** A function whose body builds shapes: run it at the origin with its
+     *  parameters bound, and return what it built — one value, or a tuple. */
+    private callShapeFunction;
     /** A solid whose extent is zero in any dimension draws nothing.
      *
      *  `sphere { size 0 }` built a mesh with an empty bounding box, and
@@ -106,19 +194,35 @@ export declare class Converter {
      *  definition and fall back to a unit size of their own. */
     private requireExtent;
     private createGeometry;
+    /** `roundrect { size w h radius r }`: the corner radius is `r` times the
+     *  smaller side (default 0.25), as upstream. */
+    private createRoundrect;
     /** A plugin extension (upstream has no torus). `size` is the OVERALL
      *  diameter, tube included, so it follows the same rule as the other curved
      *  primitives: the ring radius is what is left once the tube is subtracted.
      *  `outerRadius` (ring) and `innerRadius` (tube) override the derivation. */
     private createTorus;
-    private materialColor;
+    /** The material state a shape's own properties produce on top of `base`:
+     *  a `material` bundle first, then the individual properties, the way the
+     *  same commands would apply in order inside its block. */
+    private materialFor;
+    private applyColor;
+    /** `glow` takes a colour or a brightness; the alpha is ignored upstream. */
+    private glowColor;
+    private warnTexture;
+    private applyMaterialValue;
     private createMaterial;
     private convertCSG;
     private convertForLoop;
+    /** Expand a loop's iterable without materialising an absurd range first:
+     *  the walk stops at the budget rather than after allocating past it. */
+    private iterations;
     private convertIf;
     private convertSwitch;
     private handleDefine;
     private convertCustomShape;
+    /** Post-multiply a shape's `position` / `orientation` / `size` into a frame. */
+    private applyPlacement;
     private pushTransform;
     private popTransform;
     private currentTransform;
@@ -135,6 +239,7 @@ export declare class Converter {
     private rotationComponents;
     private handleDetail;
     private handleColorCommand;
+    private handleMaterialCommand;
     private handleRotateCommand;
     private handleOrientationCommand;
     private handleTranslateCommand;
@@ -148,7 +253,25 @@ export declare class Converter {
      *  path. Sampled at the same resolution the geometry will use, so a curve
      *  that only looks flat at low detail is not rejected. */
     private requireEnclosedArea;
+    /** `size` on an extrude: X and Y scale the profile, Z is the depth. The
+     *  depth goes into the geometry (centred on the profile plane, as
+     *  upstream), so the mesh keeps a unit Z scale. */
+    private extrudeProperties;
     private convertExtrude;
+    /** Path samples as 3D points, refused when they would not survive the trip
+     *  into a Float32 position attribute. */
+    private finitePoints;
+    /** `extrude { section … along path }`: every planar child is a section swept
+     *  along the path — its +Z turned to the path's tangent — and the sections
+     *  are joined into one solid, capped at the ends of an open path. `size`
+     *  scales the result as a whole, as on any shape. */
+    private convertExtrudeAlong;
+    /** A planar child's perimeter as a section in the XY plane, wound
+     *  counter-clockwise so the swept walls face outward. */
+    private sectionOf;
+    /** The points of the `along` path — a stroke for an open path, a planar
+     *  shape's perimeter for a closed one — built in a scratch group. */
+    private sweepPathOf;
     private buildPath;
     /** Bake the path's own `position` / `orientation` / `size` into geometry
      *  built from it. Baked rather than set on the mesh so the consuming
@@ -164,6 +287,11 @@ export declare class Converter {
      *  post-multiplied like the shape transform, and checked after every command
      *  because individually finite operands can still overflow it. */
     private collectPathPoints;
+    private placePathPoint;
+    /** `arc { angle a }`: `a` half-turns clockwise from +Y at radius `size / 2`,
+     *  placed by its own position/orientation, sampled as corners at the current
+     *  detail (upstream's own segment count for the span). */
+    private placeArc;
     private runPathLoop;
     /** Join path points into an outline, treating `curve` points as upstream does.
      *
@@ -190,20 +318,28 @@ export declare class Converter {
     private buildOperands;
     private buildFromChildren;
     private convertLoft;
+    private buildLoft;
     private planarShape;
     private convertFill;
+    /** `minkowski { a b … }`: the children summed left to right, each solid
+     *  swept over every point of the next. The result keeps the first child's
+     *  colour, as upstream keeps its material. */
+    private convertMinkowski;
     private convertHull;
     private evaluateNumber;
+    /** A `position`: one value is X alone (`position 1` is `1 0 0`, as
+     *  upstream and as `translate` here), the rest are padded with zeros. */
     private evaluateVector3;
+    /** A `size`: one value is uniform, two are `x y x` (a cylinder's diameter
+     *  and height), three are as given — Euclid's `Vector(size:)`. */
+    private evaluateSize;
+    private evaluateRGBA;
     private evaluateTranslateVector;
-    private evaluateColor;
     /** Colour channels get the same treatment as sizes and translations.
      *  `new THREE.Color(Infinity, …)` throws nothing — it serialises as
      *  `[null, null, null]`, so validation reported success and the browser was
      *  handed a material it cannot draw. */
     private requireFiniteColor;
-    private evaluateVector3OrColor;
-    private valuesEqual;
 }
 export declare function astToThreeJS(nodes: SceneNode[], options?: ConversionOptions): THREE.Group;
 //# sourceMappingURL=toThreeJS.d.ts.map

package/dist/shapescript/toThreeJS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"toThreeJS.d.ts","sourceRoot":"","sources":["../../src/shapescript/toThreeJS.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"toThreeJS.d.ts","sourceRoot":"","sources":["../../src/shapescript/toThreeJS.ts"],"names":[],"mappings":"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"}

package/dist/shapescript/types.d.ts

@@ -1,6 +1,26 @@
 export type Vector3 = [number, number, number];
 export type Color = [number, number, number];
-export type Expression = NumberLiteral | StringLiteral | IdentifierExpr | BinaryExpr | UnaryExpr | FunctionCall | MemberAccess | SubscriptExpr | TupleExpr;
+export type Expression = NumberLiteral | StringLiteral | IdentifierExpr | BinaryExpr | UnaryExpr | FunctionCall | MemberAccess | SubscriptExpr | TupleExpr | RangeExpr | MaterialExpr | ShapeExpr | ForExpr | IfExpr;
+/** A shape used as a value: `define ico icosphere { detail 0 }`. Built by the
+ *  converter into a mesh value the script can read members of and place. */
+export interface ShapeExpr {
+    type: "shape";
+    node: SceneNode;
+}
+/** `for v in iterable { expr }` as a value: the tuple of every iteration's result. */
+export interface ForExpr {
+    type: "for";
+    variable: string;
+    iterable: Expression;
+    body: Expression;
+}
+/** `if cond { a } else { b }` as a value. */
+export interface IfExpr {
+    type: "if";
+    condition: Expression;
+    then: Expression;
+    else?: Expression;
+}
 export interface NumberLiteral {
     type: "number";
     value: number;
@@ -43,21 +63,64 @@ export interface TupleExpr {
     type: "tuple";
     elements: Expression[];
 }
-export type SceneNode = ShapeNode | CSGNode | BlockNode | ForLoopNode | IfNode | SwitchNode | DefineNode | ExtrudeNode | LoftNode | LatheNode | FillNode | HullNode | GroupNode | DetailNode | SeedNode | PathNode | BackgroundNode | TextureNode | ColorNode | RotateNode | OrientationNode | TranslateNode | ScaleNode | CustomShapeNode;
+/** `from to to [step s]`, or `existing step s` when `to` is absent — a range
+ *  value a `for` loop walks and the `in` operator tests, as upstream. */
+export interface RangeExpr {
+    type: "range";
+    from: Expression;
+    to?: Expression;
+    step?: Expression;
+}
+/** `material { color … roughness … }` — a bundle of material properties that
+ *  `define` can name and the `material` command re-applies. */
+export interface MaterialExpr {
+    type: "material";
+    properties: MaterialProperties;
+}
+export interface MaterialProperties {
+    color?: Color | Expression;
+    opacity?: number | Expression;
+    metallicity?: number | Expression;
+    roughness?: number | Expression;
+    glow?: Color | Expression;
+    texture?: Expression;
+}
+export type SceneNode = ShapeNode | CSGNode | BlockNode | ForLoopNode | IfNode | SwitchNode | DefineNode | ExtrudeNode | LoftNode | LatheNode | FillNode | HullNode | MinkowskiNode | GroupNode | DetailNode | SeedNode | PathNode | BackgroundNode | MaterialNode | SmoothingNode | PrintNode | AssertNode | IgnoredNode | MeshNode | ExpressionStatementNode | ColorNode | RotateNode | OrientationNode | TranslateNode | ScaleNode | CustomShapeNode;
 export interface ShapeNode {
     type: "shape";
-    primitive: "cube" | "sphere" | "cylinder" | "cone" | "torus" | "circle" | "square" | "polygon";
+    primitive: ShapePrimitive;
     properties: ShapeProperties;
     children?: SceneNode[];
+    /** `polygon { point … }`: explicit vertices (3D), with `color` and loops,
+     *  making a single face rather than a regular polygon. */
+    points?: PathCommand[];
+}
+/** `mesh { polygon { … } … }` — a mesh assembled from polygon values. */
+export interface MeshNode {
+    type: "mesh";
+    children: SceneNode[];
+}
+/** A bare expression as a statement: a call that returns a shape (`face data`
+ *  inside `mesh`), or the value a function body ends with. */
+export interface ExpressionStatementNode {
+    type: "expression";
+    value: Expression;
 }
-export interface ShapeProperties {
+export type ShapePrimitive = "cube" | "sphere" | "icosphere" | "cylinder" | "cone" | "torus" | "circle" | "square" | "roundrect" | "polygon";
+export interface ShapeProperties extends MaterialProperties {
     position?: Vector3 | Expression;
     rotation?: Vector3 | Expression;
     orientation?: Vector3 | Expression;
     size?: Vector3 | Expression;
-    color?: Color | Expression;
-    opacity?: number | Expression;
+    /** `material name` inside a block: every property of the named bundle. */
+    material?: Expression;
+    /** Per-shape `detail` / `smoothing`, as upstream allows inside any block. */
+    detail?: number | Expression;
+    smoothing?: number | Expression;
+    name?: Expression;
     sides?: number | Expression;
+    /** `roundrect` corner radius, as a proportion of the smaller side. */
+    radius?: number | Expression;
     radiusTop?: number | Expression;
     radiusBottom?: number | Expression;
     height?: number | Expression;
@@ -73,15 +136,13 @@ export interface BlockNode {
     type: "block";
     children: SceneNode[];
 }
+/** `for v in <iterable> { … }`. The iterable is one expression: a range
+ *  (`1 to 5 step 2`, or a symbol holding one) or a tuple of values. */
 export interface ForLoopNode {
     type: "for";
     variable: string;
-    from: Expression | number;
-    to: Expression | number;
-    step?: Expression | number;
-    iterableValues?: Expression;
+    iterable: Expression;
     body: SceneNode[];
-    transforms?: TransformNode[];
 }
 export interface IfNode {
     type: "if";
@@ -108,6 +169,10 @@ export interface DefineNode {
     value?: Expression;
     options?: OptionNode[];
     body?: SceneNode[];
+    /** `define name(a b) { … }` — a function. `body` holds its statements
+     *  (defines, or shapes it builds) and `value` the expression it ends with,
+     *  if any; a function with no final expression returns what it built. */
+    params?: string[];
 }
 export interface OptionNode {
     type: "option";
@@ -127,10 +192,34 @@ export interface BackgroundNode {
     type: "background";
     value: Expression;
 }
-export interface TextureNode {
-    type: "texture";
+/** A scoped material command: `opacity 0.5`, `metallicity 1`, `roughness 0.2`,
+ *  `glow red`, `texture "file.png"` (warned, not rendered) or `material name`. */
+export interface MaterialNode {
+    type: "material";
+    property: "opacity" | "metallicity" | "roughness" | "glow" | "texture" | "material";
+    value: Expression;
+}
+/** `smoothing N` — 0 draws every edge sharp (flat shading); anything else smooth. */
+export interface SmoothingNode {
+    type: "smoothing";
+    value: Expression;
+}
+/** `print a b …` — logged, and returned to the agent with the tool result. */
+export interface PrintNode {
+    type: "print";
+    value: Expression;
+}
+/** `assert condition` — a failing assertion stops the script. */
+export interface AssertNode {
+    type: "assert";
     value: Expression;
 }
+/** A block upstream renders but this renderer does not (`camera`, `light`):
+ *  parsed and skipped, with a warning naming it. */
+export interface IgnoredNode {
+    type: "ignored";
+    command: string;
+}
 export interface ColorNode {
     type: "color";
     value: Expression;
@@ -161,6 +250,8 @@ export interface ExtrudeNode {
     path?: PathNode;
     properties: ShapeProperties;
     children?: SceneNode[];
+    /** `along <path>`: sweep the children (as sections) along this path. */
+    along?: SceneNode;
 }
 export interface LoftNode {
     type: "loft";
@@ -182,6 +273,12 @@ export interface HullNode {
     properties: ShapeProperties;
     children: SceneNode[];
 }
+/** `minkowski { a b … }`: the Minkowski sum of its children, left to right. */
+export interface MinkowskiNode {
+    type: "minkowski";
+    properties: ShapeProperties;
+    children: SceneNode[];
+}
 export interface GroupNode {
     type: "group";
     children: SceneNode[];
@@ -194,11 +291,29 @@ export interface PathNode {
      *  `loft` section is placed in 3D without a wrapping `fill`. */
     properties?: ShapeProperties;
 }
-export type PathCommand = DefineNode | PointCommand | CurveCommand | RotateCommand | TranslateCommand | ScaleCommand | DetailPathCommand | ForLoopPathCommand;
+export type PathCommand = DefineNode | PointCommand | CurveCommand | ArcCommand | RotateCommand | TranslateCommand | ScaleCommand | DetailPathCommand | ColorPathCommand | ForLoopPathCommand;
+/** `color …` inside a path or polygon block: the colour of the points that follow. */
+export interface ColorPathCommand {
+    type: "color";
+    value: Expression;
+}
 export interface PointCommand {
     type: "point";
     x: number | Expression;
     y: number | Expression;
+    /** A third coordinate is accepted for upstream compatibility; paths here are
+     *  planar, so it must be zero. */
+    z?: Expression;
+}
+/** `arc { angle A [position] [orientation] [size] }` inside a path: a circular
+ *  arc of `angle` half-turns, clockwise from +Y, radius `size / 2` (default
+ *  0.5), sampled at the current detail. */
+export interface ArcCommand {
+    type: "arc";
+    angle?: Expression;
+    position?: Expression;
+    orientation?: Expression;
+    size?: Expression;
 }
 /** A quadratic Bézier CONTROL point. The curve passes through the neighbouring
  *  `point`s, not through this one; two `curve`s in a row get an implicit
@@ -207,6 +322,7 @@ export interface CurveCommand {
     type: "curve";
     x: number | Expression;
     y: number | Expression;
+    z?: Expression;
 }
 export interface RotateCommand {
     type: "rotate";
@@ -231,14 +347,14 @@ export interface DetailPathCommand {
 export interface ForLoopPathCommand {
     type: "for";
     variable: string;
-    from: number | Expression;
-    to: number | Expression;
-    step?: number | Expression;
+    iterable: Expression;
     commands: PathCommand[];
 }
 export declare enum TokenType {
     CUBE = "CUBE",
     SPHERE = "SPHERE",
+    ICOSPHERE = "ICOSPHERE",
+    ROUNDRECT = "ROUNDRECT",
     CYLINDER = "CYLINDER",
     CONE = "CONE",
     TORUS = "TORUS",
@@ -250,14 +366,24 @@ export declare enum TokenType {
     LATHE = "LATHE",
     FILL = "FILL",
     HULL = "HULL",
+    MINKOWSKI = "MINKOWSKI",
     GROUP = "GROUP",
+    MESH = "MESH",
     PATH = "PATH",
     POINT = "POINT",
     CURVE = "CURVE",
+    ARC = "ARC",
     DETAIL = "DETAIL",
+    SMOOTHING = "SMOOTHING",
     SEED = "SEED",
     BACKGROUND = "BACKGROUND",
     TEXTURE = "TEXTURE",
+    MATERIAL = "MATERIAL",
+    METALLICITY = "METALLICITY",
+    ROUGHNESS = "ROUGHNESS",
+    GLOW = "GLOW",
+    PRINT = "PRINT",
+    ASSERT = "ASSERT",
     UNION = "UNION",
     DIFFERENCE = "DIFFERENCE",
     INTERSECTION = "INTERSECTION",
@@ -285,6 +411,8 @@ export declare enum TokenType {
     NUMBER = "NUMBER",
     IDENTIFIER = "IDENTIFIER",
     STRING = "STRING",
+    /** `#RGB`, `#RGBA`, `#RRGGBB` or `#RRGGBBAA`; the value is the digits. */
+    HEXCOLOR = "HEXCOLOR",
     PLUS = "PLUS",
     MINUS = "MINUS",
     STAR = "STAR",