openscad-cpp-evaluator 0.40.0__tar.gz → 0.50.0__tar.gz

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/CLAUDE.md

@@ -45,9 +45,13 @@ comprehension clause kinds, user function calls (recursion, defaults, `FunctionL
 user module calls (`children()`/`children(N)`, closure detection via `callCtxFor`), list
 indexing/swizzle member access; the full math/string/list/type-check builtin *function* dispatch
 (`sin`/`cos`/`pow`/`search`/`lookup`/`chr`/`ord`/`is_*`/`object`/`has_key`/etc, ~43 names — a
-completely separate namespace/precedence rule from the builtin *modules* in `registry.cpp`: a
-builtin function name always wins over a same-named user function, checked *before* the
-user-function lookup), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
+same precedence rule as the builtin *modules* in `registry.cpp`: a user-defined function
+**shadows** a same-named builtin, looked up *before* the builtin table. This was backwards until
+0.47.0 — the port copied the old Python evaluator's `_eval_function_call` order, which had it
+wrong; OpenSCAD 2026.02.01 echoes 999 for `function abs(x)=999; abs(-3)` and we echoed 3. Fixing
+it needs **both** resolution sites: `evalFunctionCall` (`user_calls.cpp`) and the compiler's
+call-site resolution (`bytecode_compiler.cpp`), which bakes builtin-vs-user in at compile time,
+plus gating the silent `is_undef` probe on the call actually resolving to the builtin), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
 (VNF/JSON) contexts, and 3MF read/write; (Phase 6) `hull()`/`minkowski()` (transparent-splice
 CSG-tree shape like union/difference/intersection, role-split via the shared `splitByRole`),
 `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`, and `roof()`; and (Phase 7) `offset()`,
@@ -441,6 +445,111 @@ handling in arithmetic, the closure-detection rule for `call_ctx` vs `child_ctx`
 verbatim port, not an independent design. Deliberate divergences are called out in code comments —
 grep for `ponytail:`.
 
+- **Feature detection** — `$_SUPPORTED_FEATURE` (just `true`; names the CAPABILITY rather than the
+  vendor, so any evaluator adding `supported_feature()` is meant to set it, and checking it first
+  solves the bootstrapping problem of calling a function you don't know exists. Written
+  `!is_undef($_SUPPORTED_FEATURE) && supported_feature(...)` the guard is **silent** in OpenSCAD --
+  `is_undef()` is the one way to read an unknown variable there without a warning, and `&&`
+  short-circuits past the unknown call; verified against the reference), `$_BELFRYSCAD` (seeded in `EvalContext::makeRoot`, `src/eval_context.cpp`, as
+  `[major, minor, patch]` from `OSCAD_EVAL_VERSION_*` compile definitions that the top-level
+  `CMakeLists.txt` parses out of `pyproject.toml`, so wheel and local builds cannot disagree and a
+  bump needs one edit) and `supported_feature("name")` (`featureLevels()` in
+  `src/builtins/function_builtins.cpp`, returning a LEVEL so a feature whose semantics change can
+  be told from its earlier self; 0 for unknown names and non-string arguments, deliberately
+  silent so probing for a future feature is safe). Both exist because OpenSCAD **silently ignores**
+  unknown arguments -- `children(separate=true)` renders the wrong shape there with no warning --
+  and both read as `undef` in OpenSCAD, so a guard written against them works in both.
+
+- **`levelset(field, bounds, isovalue)`** (`src/builtins/topology.cpp`, feature name `levelset`) —
+  a solid from a grid of sampled values: `field[i][j][k]` with i,j,k mapping to x,y,z. Wraps
+  `Manifold::LevelSet` with a C++ trilinear-sampling lambda; no new Manifold API.
+  **The field is a grid OR a `function(x,y,z)`, and the two trade off against each other** —
+  neither is simply better:
+
+  | | sampling | parallel | accuracy | ceiling |
+  |---|---|---|---|---|
+  | grid `field[i][j][k]` | 0.41 µs | **yes** | capped by the grid | ~550 MB at 200³ |
+  | `function(x,y,z)` | 0.96 µs | **no** | Manifold snaps toward the true surface | none |
+
+  Measured at matched resolution against the analytic sphere: **50³ grid 0.23 s (−0.244%) vs
+  function 0.32 s (−0.103%); 100³ grid 1.06 s (−0.059%) vs function 1.91 s (−0.025%)**. So the
+  function form is ~1.5× slower and ~2.4× more accurate. Both still beat BOSL2.
+  `canParallel` is the crux and is **not a tuning knob**: true for a grid because the lambda is
+  pure C++, false for a function because Manifold warns that parallel policies "will crash
+  language runtimes with runtime locks that expect to not be called back by unregistered threads".
+  The function form also needs `edge=` explicitly — there is no grid to infer spacing from and the
+  cost is cubic in it, so guessing would silently produce either a useless mesh or a ten-minute
+  one.
+  Measured against BOSL2's `isosurface.scad` (217 KB of marching cubes in script), same field:
+  **50³ 0.26 s vs 2.07 s (8.0×), 100³ 1.15 s vs 14.59 s (12.7×)**.
+  The trade is **memory**: ~67 bytes/cell, so 200³ ≈ 550 MB is the practical ceiling. A callback
+  samples lazily and has none.
+  **Accuracy is bounded by the grid, not by Manifold.** It samples on a body-centred cubic lattice
+  (`sdf.cpp:440-446`) so a plain cubic grid does not line up and the lambda interpolates — same
+  accuracy as grid-based marching cubes in script, worse than `LevelSet` given a true SDF. Hence
+  `tolerance = -1` is forced: a positive value makes Manifold do extra evaluations per vertex that
+  would only re-interpolate data already used. `edgeLength` defaults to the grid spacing for the
+  same reason.
+  Calling the field function from the generate pass has no live `EvalContext`, so a root is built
+  from the closure's own scope — `$`-variables sit at their defaults inside it.
+  Sign convention: Manifold takes positive as inside; a distance field is the other way round, so
+  the default flips it and `invert=true` flips back.
+  Two behaviours that look alike and are opposite: an isovalue **nothing reaches** gives empty
+  geometry; one **everything satisfies** gives the whole bounding box. Both are tested.
+
+- **`linear_solve(A, b)`** (`src/builtins/function_builtins.cpp`, feature name `linear-solve`) —
+  returns `.x` (solution), `.det`, `.singular`. Dispatches on shape:
+
+  | shape | method | `.x` | `.det` |
+  |---|---|---|---|
+  | m = n | pivoted **LU** | the solution | product of U's diagonal, signed by row swaps |
+  | m > n | **Householder QR** | least squares | `undef` |
+  | m < n | **QR of Aᵀ** | minimum norm | `undef` |
+
+  Q is never formed. The reflectors are stored below the diagonal (v[0]
+  normalised to 1, scale in `taus`) and applied in forward order for `Qᵀb`,
+  reverse order for `Qy` — which is why this is far smaller and quicker than
+  BOSL2, whose QR materialises an m×m Q *and* an n×n permutation matrix and
+  then multiplies by it. **Minimum norm** comes from padding `y` with zeros to
+  length n before applying Q; a residual check alone will NOT catch getting
+  that wrong, since any solution passes it — assert the norm.
+  Rank deficiency without column pivoting cannot distinguish rank-deficient
+  from very ill-conditioned. It is a relative-tolerance heuristic on the
+  diagonal; say so rather than implying it is exact.
+
+  **Named to collide, deliberately.** BOSL2 defines `linear_solve()`, and since
+  0.47.0 a user function *shadows* a builtin — so this is unreachable from any
+  script that includes BOSL2 until BOSL2 drops its own. That is the intended
+  path (BelfrySCAD's author maintains BOSL2); callers then gain a `.x`, since
+  BOSL2's returns the bare solution and `[]` for singular. **Do not "fix" the
+  shadowing to make this reachable** — the shadowing is the correct, reference-
+  matching behaviour, and was itself a bug fix.
+
+  Measured per call, BOSL2 load subtracted, enough repetitions to clear noise
+  (harness checked: 200/2000/20000 reps at n=64 give 43/45/43 µs):
+
+  | n | BOSL2 `linear_solve` | ours | | n | BOSL2 `determinant` | ours |
+  |---:|---:|---:|---:|---:|---:|---:|
+  | 4 | 280 µs | 1.5 µs | 187× | 10 | 3.17 s | 0.33 s |
+  | 16 | 2.58 ms | 4.0 µs | 644× | 11 | 31.49 s | 0.33 s |
+  | 64 | 42.5 ms | 43 µs | 988× | | *cofactor expansion, O(n!)* | |
+
+  **Do not repeat the claim this replaces**: that BOSL2's solve "is not the
+  problem (128×128 in ~0.18s)". That was one-shot, with the solve lost inside
+  BOSL2's own load time. Keep the comparison fair though — BOSL2 does QR where
+  the square path here does LU, and it validates arguments every call.
+  Also correctness, not only speed: BOSL2's singularity test is a fixed
+  **absolute** `1e-9` on R's diagonal, unscaled by ‖A‖, so `2*I` scaled by
+  1e-10 is called singular there and solves correctly here.
+
+  **Profiling that shaped the scope** (don't redo it): NURBS *evaluation* is
+  0.6% linear algebra — basis eval 44%, type checks 25%. NURBS *interpolation*
+  is 35% at n=400, and every hot solve is **square**, so the QR paths are a
+  capability, not a measured win. `plane_intersection` (2×3, underdetermined)
+  is 0.1% of a `rounded_prism` model. The recurring cost across every workload
+  profiled is BOSL2's **argument type-checking**: 25–45%, millions of
+  `is_finite`/`is_num`/`is_nan` calls.
+
 - `include/openscad_cpp_evaluator/value.hpp`, `src/value.cpp` — the `Value` variant (OpenSCAD's
   dynamic value type) and its free-function arithmetic/comparison helpers. See the plan's §1 for
   the type-mapping table and why there's no numpy-equivalent library.
@@ -481,7 +590,19 @@ grep for `ponytail:`.
   lexically nested inside an already-active call," picking `childCtx()` vs `callCtx()`
   accordingly; read its doc comment before touching it, it's the second-trickiest mechanism in this
   codebase after the CSG tree stack), `evalUserModule`/`evalUserFunction`/`evalFunctionLiteral`,
-  and `builtinChildren` (children()/children(N), deferred evaluation). `evalFunctionCall`'s
+  and `builtinChildren` (children()/children(N), deferred evaluation).
+  **`children(..., separate=true)`** is a BelfrySCAD extension handled *before* any of that, by
+  `expandChildStatements`: a block is read with each separating forward replaced by one synthetic
+  `children(k)` statement per child it selects (`makeChildrenIndexCall`, owned by
+  `syntheticNodes_` and cleared with `idToNode` at `resolveTreeImpl` entry). Everything the
+  feature does follows from their being real statements -- `$children` counts them,
+  `children(i)` indexes them, and `union`/`difference`/`intersection` give each its own operand
+  group -- with no flag on `CSGNode` and nothing to leak. Called from `buildModuleChildCtx`,
+  `resolveCsg`, `resolveIntersectionFor`, and the VM's `Op::CsgGroupChildren`, which exists
+  because the compiler fixes group boundaries long before `$children` (and so the expansion size)
+  is knowable; it shares `expandSeparatingChildren` with the interpreter so the engines cannot
+  drift. Synthetic calls carry the author's own `Position` and no scope, so they resolve in the
+  evaluating context (`evalChildren`'s `runAll`). `evalFunctionCall`'s
   precedence order (checked in this exact sequence): `import` (special-cased, its own
   module/expression-context split) → `isBuiltinFunctionName` (function_builtins.hpp — always wins
   if true) → user function lookup → function-literal *value* probe → "unknown function" warning.
@@ -684,8 +805,17 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — binary STL, OBJ, OFF, and 3MF
-  writers (compose every body into one solid first; 3MF via `zip_stored.hpp`'s `writeDeflateZip`).
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eight
+  formats `exportExtensions()` lists: 3MF, AMF, STL, OBJ, OFF, PLY, VRML, X3D (3MF via
+  `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
+  which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
+  restating the list, because three hand-written copies had already drifted far enough that `.off`
+  could be written by neither the GUI nor the CLI while every test passed.
+  Colour is carried by 3MF, AMF, OBJ (companion `.mtl`), PLY, VRML and X3D; STL and OFF compose
+  every body into one solid and store geometry only. **AMF** puts colour on the `<volume>` rather
+  than the face, so an object whose triangles are not all one colour is written as one volume per
+  colour — per-triangle `<color>` is legal in the spec but poorly supported by the slicers that are
+  the audience for it.
   `colored_body.hpp`/`.cpp`'s `toRenderableBodies()` (thin-extrudes any top-level 2D-only result to
   a 1e-3-unit-tall `flatPreview` Manifold) must run on a body list before handing it to any of these
   writers — none of them look at `ColoredBody::section` at all, only `.body`. `tools/cli/cli_lib.cpp`

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/CMakeLists.txt

@@ -1,5 +1,17 @@
 cmake_minimum_required(VERSION 3.24)
-project(openscad_cpp_evaluator CXX)
+
+# Read the version straight out of pyproject.toml rather than repeating it
+# here. It reaches C++ as OSCAD_EVAL_VERSION_{MAJOR,MINOR,PATCH} (see
+# src/CMakeLists.txt), which is what seeds $_BELFRYSCAD -- so a released
+# wheel and a local `cmake --build` always report the same numbers, and a
+# version bump needs one edit, not three.
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/pyproject.toml" _oscad_pyproject)
+if(NOT _oscad_pyproject MATCHES "\nversion = \"([0-9]+)\.([0-9]+)\.([0-9]+)\"")
+    message(FATAL_ERROR "could not read version = \"X.Y.Z\" from pyproject.toml")
+endif()
+set(OSCAD_EVAL_VERSION "${CMAKE_MATCH_1}.${CMAKE_MATCH_2}.${CMAKE_MATCH_3}")
+
+project(openscad_cpp_evaluator VERSION ${OSCAD_EVAL_VERSION} LANGUAGES CXX)
 
 # On Apple Silicon, warn (don't fail -- a universal or intentionally-x86_64
 # build is legitimate) if the effective target architecture is x86_64 while

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 0.40.0
+Version: 0.50.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/bindings/module.cpp

@@ -385,17 +385,36 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
     {
         nb::gil_scoped_release rel;
         auto logFn = [&echoes](const std::string& m) { echoes.push_back(m); };
-        std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(path);
-        oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, logFn);
-        oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
-        oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
-        bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
-        collectIdSpans(ev, idSpans);
-        csgTree = std::move(ev.csgTree);
-        profileResult = std::move(ev.profileResult);
-        {
-            nb::gil_scoped_acquire g; // building Python objects needs the GIL back
-            std::tie(dyn, dynExplicit) = dynStateToPy(ctx);
+        try {
+            std::vector<std::unique_ptr<oscad::ASTNode>> ast = oscad::getASTFromFile(path);
+            oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(ast, path, logFn);
+            oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
+            oscadeval::EvalContext ctx = oscadeval::EvalContext::makeRoot(used.rootScope.get());
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp));
+            collectIdSpans(ev, idSpans);
+            csgTree = std::move(ev.csgTree);
+            profileResult = std::move(ev.profileResult);
+            {
+                nb::gil_scoped_acquire g; // building Python objects needs the GIL back
+                std::tie(dyn, dynExplicit) = dynStateToPy(ctx);
+            }
+        } catch (const std::exception& e) {
+            // `echoes` is a local, so letting this unwind past here loses
+            // every echo and warning the script produced BEFORE it failed --
+            // which is exactly the output you want when something fails. The
+            // batching that makes them cheap (no GIL round-trip per line) is
+            // also what made them disposable.
+            //
+            // Carry them out on the exception itself: args = (message,
+            // [echo, ...]). The facade replays them through echo_fn and then
+            // re-raises. Anything that only looks at str(e) is unaffected,
+            // since args[0] is still the formatted diagnostic.
+            nb::gil_scoped_acquire g;
+            nb::list partial;
+            for (const std::string& s : echoes) partial.append(s);
+            nb::object args = nb::make_tuple(nb::str(e.what()), partial);
+            PyErr_SetObject(PyExc_RuntimeError, args.ptr());
+            throw nb::python_error();
         }
     }
 
@@ -767,6 +786,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
           "file cannot be opened.");
 
+    m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
+          "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "
+          "rather than restated here, so the Python side cannot drift from what can actually be written.");
+
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
           nb::arg("profile") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/ast/expression.hpp

@@ -80,14 +80,22 @@ public:
 class RangeLiteral : public Primary {
 public:
     RangeLiteral(Position position, std::unique_ptr<Expression> start, std::unique_ptr<Expression> end,
-                 std::unique_ptr<Expression> step)
+                 std::unique_ptr<Expression> step, bool implicitStep = false)
         : Primary(NodeKind::RangeLiteral, std::move(position)), start(std::move(start)), end(std::move(end)),
-          step(std::move(step)) {}
+          step(std::move(step)), implicitStep(implicitStep) {}
 
     std::unique_ptr<Expression> start;
     std::unique_ptr<Expression> end;
     std::unique_ptr<Expression> step;
 
+    // True when the source wrote the two-argument form `[a:b]` and the step
+    // node below is the literal 1.0 this parser synthesized for it. Consumers
+    // that only need the value can ignore this and read `step` as always
+    // present; it exists because "the author did not choose a step" is not
+    // recoverable from the synthesized node, and the evaluator's backwards-range
+    // warning fires only for that case (an explicit step is taken as deliberate).
+    bool implicitStep = false;
+
     std::string toString() const override;
     void buildScope(Scope& parentScope) override;
 };

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/external/openscad_cpp_parser/src/ast/expression.cpp

@@ -22,6 +22,10 @@ std::string NumberLiteral::toString() const {
 }
 
 std::string RangeLiteral::toString() const {
+    // Print back the form that was written. Emitting the synthesized step for
+    // a two-argument range would round-trip `[5:0]` into `[5 : 1 : 0]`, which
+    // reads identically but suppresses the evaluator's backwards-range warning.
+    if (implicitStep) return "[" + start->toString() + " : " + end->toString() + "]";
     return "[" + start->toString() + " : " + step->toString() + " : " + end->toString() + "]";
 }
 

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/external/openscad_cpp_parser/src/grammar/driver.cpp

@@ -46,11 +46,13 @@ NodePtr makeUndefinedLiteral(ParserDriver& driver, const OscadLocation& loc) {
 }
 
 NodePtr makeRangeLiteral(ParserDriver& driver, const OscadLocation& loc, NodePtr start, NodePtr end, NodePtr step) {
-    if (!step) {
+    const bool implicitStep = !step;
+    if (implicitStep) {
         step = std::make_unique<NumberLiteral>(driver.toPosition(loc), 1.0);
     }
     return std::make_unique<RangeLiteral>(driver.toPosition(loc), nodeCast<Expression>(std::move(start)),
-                                           nodeCast<Expression>(std::move(end)), nodeCast<Expression>(std::move(step)));
+                                           nodeCast<Expression>(std::move(end)), nodeCast<Expression>(std::move(step)),
+                                           implicitStep);
 }
 
 NodePtr makePositionalArgument(ParserDriver& driver, const OscadLocation& loc, NodePtr expr) {

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/external/openscad_cpp_parser/src/serialization/json_io.cpp

@@ -112,6 +112,7 @@ json toJsonImpl(const ASTNode& node, bool includePos) {
             j["start"] = valueToJson(n.start.get(), includePos);
             j["end"] = valueToJson(n.end.get(), includePos);
             j["step"] = valueToJson(n.step.get(), includePos);
+            if (n.implicitStep) j["implicitStep"] = true;
             break;
         }
         case NodeKind::ParameterDeclaration: {
@@ -410,7 +411,8 @@ const std::unordered_map<std::string, Builder>& registry() {
         {"RangeLiteral",
          [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {
              return std::make_unique<RangeLiteral>(std::move(pos), childFromJson<Expression>(j, "start"),
-                                                    childFromJson<Expression>(j, "end"), childFromJson<Expression>(j, "step"));
+                                                    childFromJson<Expression>(j, "end"), childFromJson<Expression>(j, "step"),
+                                                    j.value("implicitStep", false));
          }},
         {"ParameterDeclaration",
          [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/external/openscad_cpp_parser/tests/test_pretty_print.cpp

@@ -515,3 +515,16 @@ TEST(PrettyPrint, AssignmentRhsWithLeadingCommentAndTrailingLineComment) {
 // no other translation unit -- including this test file -- can name them.
 // Left as a known, permanent coverage ceiling rather than weakening the
 // encapsulation just to reach 100%.
+
+// The two-argument range keeps its shape through a print/reparse cycle.
+// It would be easy to always print the synthesized step, and the result
+// would still be a correct program -- but `[5:0]` and `[5:1:0]` mean
+// different things to the evaluator's backwards-range warning, so
+// reformatting a file must not quietly convert one into the other.
+TEST(PrettyPrint, ImplicitRangeStepSurvivesRoundTrip) {
+    auto ast = parseAst("a = [5:0];\nb = [5:1:0];\n");
+    const std::string printed = toOpenscad(ast);
+    EXPECT_NE(printed.find("[5 : 0]"), std::string::npos) << printed;
+    EXPECT_NE(printed.find("[5 : 1 : 0]"), std::string::npos) << printed;
+    expectStablePrint("a = [5:0];\nb = [5:1:0];\n");
+}

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -426,6 +426,21 @@ enum class Op {
     // own `groupSizes.push_back(Value{...})` loop.
     CsgGroupEnd,
 
+    // One `children(..., separate=true)` statement inside a CSG bracket.
+    // `a` interns the ModularCall in nativeStatements.
+    //
+    // A statement of its own, rather than a CsgGroupStart/End pair around
+    // compiled code, because how many groups it contributes is only known
+    // at RUNTIME -- `children([2:$children-1], separate=true)` reads
+    // $children, and the compiler emits its group boundaries long before
+    // any of that exists. So this op expands the call (the same
+    // Evaluator::expandSeparatingChildren the interpreter uses, so the two
+    // engines cannot drift) and records one group per expanded statement.
+    //
+    // Not an interpreter bail: the forwarded statements go through
+    // evalChildren, which self-gates and retries its own compiled chunks.
+    CsgGroupChildren,
+
     // Closes the matching Op::PushCsgWrap bracket: pops
     // VmFrame::csgWrapStack's own top entry FIRST (before anything that can
     // itself throw, e.g. setTreeDepthOrThrow below -- same "exception-

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -34,6 +34,7 @@ struct CSGNode {
     CSGParams params;                      // resolve step's plain-data output
     bool uncacheable = false;              // set by a later phase (ManifoldCache, Phase 8)
 
+
     // The call site that entered this node's call chain from the top
     // level, captured at RESOLVE time -- non-owning, AST-lifetime-bound
     // like `node`. nullptr for a node resolved at top level.
@@ -73,4 +74,5 @@ struct CSGNode {
     std::optional<std::string> cachedKey;
 };
 
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -190,6 +190,7 @@ public:
     // statement.
     size_t currentTreeFrameSize() const { return treeStack_.back().size(); }
 
+
     // Generate pass: walks `tree` bottom-up (children before their own
     // node), calling each node's registered GenerateFn (falling back to
     // concatenating children's bodies for a kind with none registered).
@@ -342,9 +343,56 @@ public:
     struct ChildrenForward {
         EvalContext evalCtx;
         std::vector<const oscad::ASTNode*> nodes;
+        // The `separate` flag as written at the call. Read by
+        // expandSeparatingChildren, which turns the forward into one
+        // statement per child; builtinChildren itself ignores it, since by
+        // the time a forward runs the expansion has already happened.
+        bool separate = false;
+        // Which of the caller's geometry statements `nodes` came from, in
+        // the same order. Needed by expandChildStatements, which turns each
+        // one back into its own `children(k)` statement.
+        std::vector<size_t> pickedIndices;
     };
     std::optional<ChildrenForward> prepareChildrenForward(const CallArgs& args, EvalContext& ctx);
 
+    // A child-statement block with every `children(..., separate=true)`
+    // replaced by one synthetic `children(k)` statement per child it
+    // selects. That is the whole of what separate=true does: the forwarded
+    // children become real, countable statements at this call site, so
+    // $children sees them, children(i) indexes them, and a boolean operator
+    // gives each its own operand group -- all for free, because they ARE
+    // statements rather than nodes wearing a flag.
+    //
+    // Called wherever a block is consumed: a module call's children
+    // (buildModuleChildCtx), and union/difference/intersection/
+    // intersection_for's own child list.
+    std::vector<const oscad::ASTNode*> expandChildStatements(
+        const std::vector<std::unique_ptr<oscad::ASTNode>>& block, EvalContext& ctx);
+
+    // One synthetic `children(index)` statement, owned by syntheticNodes_.
+    const oscad::ASTNode* makeChildrenIndexCall(const oscad::ModularCall& origin, size_t index);
+
+    // The sole argument of `is_undef(x)` when x is a bare identifier, else
+    // nullptr. That call is a PROBE -- asking whether a name is defined must
+    // not itself complain that it isn't -- so the name is read with
+    // warnIfUndef=false. Static and syntactic so the bytecode compiler can
+    // ask at compile time and emit LoadFreeNoWarn.
+    static const oscad::Identifier* undefProbeTarget(const oscad::PrimaryCall& call);
+
+    // Syntactic gate: is this statement a `children(..., separate=true)`?
+    // Cheap and side-effect-free, so the bytecode compiler can ask it at
+    // COMPILE time to decide which opcode to emit, long before the flag's
+    // value (or the child count it selects) is knowable.
+    static bool isSeparatingChildrenCall(const oscad::ASTNode& stmt);
+
+    // The runtime half: the statements `call` expands to. nullopt means the
+    // `separate` flag resolved falsey after all, and the caller should run
+    // the original statement unchanged. Shared by expandChildStatements
+    // (interpreter) and Op::CsgGroupChildren (VM) so the engines cannot
+    // drift on what expansion means.
+    std::optional<std::vector<const oscad::ASTNode*>> expandSeparatingChildren(const oscad::ModularCall& call,
+                                                                               EvalContext& ctx);
+
     // "WARNING: {message}{locSuffix(position)}" via echoFn_, no-op if unset.
     // Public: builtins/import.cpp's not-manifold warning is emitted from a
     // free function, same reasoning as tagGenerated()/builtinChildren().
@@ -392,7 +440,12 @@ public:
     Value applyUnaryOp(oscad::NodeKind kind, const Value& v, const oscad::Position& pos);
     Value applyIndexAccess(const Value& obj, const Value& idx);
     Value applyMemberAccess(const Value& obj, const std::string& member);
-    Value applyRange(const Value& startV, const Value& endV, const Value& stepV);
+    // `implicitStep` is the RangeLiteral's own flag: true when the source
+    // wrote `[a:b]` and the parser supplied the 1.0. It only affects whether
+    // the backwards-range warning fires; the resulting value is the same
+    // either way. `pos` locates that warning.
+    Value applyRange(const Value& startV, const Value& endV, const Value& stepV, bool implicitStep = false,
+                     const oscad::Position* pos = nullptr);
 
     // Entry point for a call site resolved INSIDE compiled bytecode (the
     // CALL_FN opcode, bytecode_vm.cpp): `bound` is already fully evaluated
@@ -1622,6 +1675,12 @@ public:
     // is on top *at that moment* -- the frame this node's own build call
     // pushed just before resolving. See csg_resolve.cpp for the full
     // push/call/pop sequence.
+    // Synthetic `children(k)` calls built by expandChildStatements. Owned
+    // here because CSGNode::node and idToNode hold non-owning pointers into
+    // them, so they must outlive the pass; cleared with those maps at
+    // resolveTreeImpl entry.
+    std::vector<std::unique_ptr<oscad::ASTNode>> syntheticNodes_;
+
     std::vector<std::vector<std::unique_ptr<CSGNode>>> treeStack_;
 
 private:

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/include/openscad_cpp_evaluator/export.hpp

@@ -97,6 +97,13 @@ void writeVrml(const std::string& path, const std::vector<ExportObject>& objects
 // Color) and Shape level 1 (Appearance, Material), exactly the nodes used.
 void writeX3d(const std::string& path, const std::vector<ExportObject>& objects);
 
+// AMF 1.1. XML like X3D, but its colour lives on the <volume>, not the
+// face: a mesh holds one vertex list and one <volume> per material. An
+// object whose triangles are not all one colour therefore becomes several
+// volumes -- which is what a multimaterial slicer reads as separate
+// materials to assign to tools.
+void writeAmf(const std::string& path, const std::vector<ExportObject>& objects);
+
 // OFF (Object File Format): header "OFF", "$verts $tris 0", vertex lines,
 // then "3 i j k" per triangle (0-indexed, count-prefixed). Mirrors
 // export.py's write_off.

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/include/openscad_cpp_evaluator/value.hpp

@@ -355,20 +355,6 @@ private:
 // it, keeping expandIterable() itself free of any Evaluator/echo coupling.
 using RangeTooManyFn = std::function<void(size_t count)>;
 
-// Called when a range's step points AWAY from its end -- begin > end with a
-// positive step, or begin < end with a negative step. Such a range is
-// naturally empty, and the reference warns rather than iterating zero times
-// in silence. `stepPositive` picks which of its two messages applies; use
-// rangeDirectionWarning() to build the text.
-//
-// Separate from RangeTooManyFn for the same reason that one exists: it
-// keeps expandIterable() free of any Evaluator/echo coupling.
-using RangeDirectionFn = std::function<void(bool stepPositive)>;
-
-// The reference's own wording, quoted verbatim, for a range whose step
-// points away from its end. Shared so the five call sites cannot drift.
-std::string rangeDirectionWarning(bool stepPositive);
-
 // Converts a for()/intersection_for() loop assignment's evaluated RHS into
 // the sequence of values to iterate: undef -> empty, range -> a LAZY
 // sequence (matching OscRange's own start/step/end iteration, half-open
@@ -394,8 +380,7 @@ std::string rangeDirectionWarning(bool stepPositive);
 // one with a live consumer (BelfrySCAD) that surfaced it. The count is
 // computed in closed form (not IterableValues::size()'s O(n) walk) so a
 // legitimate huge-but-under-the-limit range never pays an eager pass.
-IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany = nullptr,
-                               const RangeDirectionFn& onWrongDirection = nullptr);
+IterableValues expandIterable(const Value& v, const RangeTooManyFn& onTooMany = nullptr);
 
 // `each <body>`'s own flatten-one-level rule, shared by the AST interpreter
 // (evalListLiteral/evalListElement's ListCompEach handling, expr_eval.cpp)

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "0.40.0"
+version = "0.50.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/python/openscad_cpp_evaluator/__init__.py

@@ -315,8 +315,14 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
 
 
 def export_extensions() -> list:
-    """The file extensions export_model understands, dot-prefixed."""
-    return [".3mf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"]
+    """The file extensions export_model understands, dot-prefixed.
+
+    Asked of the extension rather than restated here. The hardcoded copy
+    this replaces had already drifted: it was missing formats the C++
+    writer table had gained, and nothing failed -- callers simply could
+    not reach them.
+    """
+    return list(_ext.export_extensions())
 
 
 def check_mesh(verts, tris) -> dict:
@@ -504,6 +510,17 @@ class Evaluator:
         except EvalError:
             raise
         except Exception as e:  # ParseError/EvalError from C++ arrive as RuntimeError
+            # The binding attaches whatever the script echoed before it failed
+            # as args[1] (see bindings/module.cpp). Replay it first: a failed
+            # run's own output is the most useful thing it produced, and
+            # dropping it means the console shows the error with none of the
+            # context that led to it.
+            args = getattr(e, "args", ())
+            if len(args) == 2 and isinstance(args[1], list):
+                if self._echo_fn:
+                    for line in args[1]:
+                        self._echo_fn(line)
+                raise EvalError(str(args[0])) from e
             raise EvalError(str(e)) from e
         bodies = bodies_from_dicts(body_dicts)
         # originalID -> a node with `.position` (start/end offsets) for WYSIWYG

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/src/CMakeLists.txt

@@ -46,6 +46,14 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/surface.cpp
 )
 
+# Seeds $_BELFRYSCAD (eval_context.cpp). Parsed from pyproject.toml by the
+# top-level CMakeLists so there is one source of truth for the version.
+target_compile_definitions(openscad_cpp_evaluator PRIVATE
+  OSCAD_EVAL_VERSION_MAJOR=${PROJECT_VERSION_MAJOR}
+  OSCAD_EVAL_VERSION_MINOR=${PROJECT_VERSION_MINOR}
+  OSCAD_EVAL_VERSION_PATCH=${PROJECT_VERSION_PATCH}
+)
+
 target_include_directories(openscad_cpp_evaluator PUBLIC
   $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
 )

{openscad_cpp_evaluator-0.40.0 → openscad_cpp_evaluator-0.50.0}/src/builtins/booleans.cpp

@@ -68,7 +68,13 @@ std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBo
 // operand (unioned together), and each subsequent statement's bodies are
 // unioned then subtracted -- a flat evaluation would lose this grouping and
 // misbehave when e.g. BOSL2's attachable() returns multiple bodies (parent
-// + attached children) as one operand. Mirrors _resolve_csg/_generate_csg,
+// + attached children) as one operand.
+//
+// One statement can still turn into several: children(separate=true) is
+// expanded into one `children(k)` statement per child it forwards, before
+// this loop ever sees the block (Evaluator::expandChildStatements), which is
+// how `difference() children(separate=true)` subtracts children 1..n from
+// child 0. Nothing special happens here -- they are simply statements. Mirrors _resolve_csg/_generate_csg,
 // minus _attach_tri_colors' multi-color-merge provenance (ponytail: a
 // merged body always takes its first contributing child's color, matching
 // this evaluator's own pre-tri_colors baseline behavior -- revisit
@@ -87,11 +93,11 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
 
     std::vector<const oscad::ASTNode*> assignNodes;
     std::vector<const oscad::ASTNode*> geoNodes;
-    for (const auto& c : node.children) {
+    for (const oscad::ASTNode* c : ev.expandChildStatements(node.children, effCtx)) {
         if (c->kind() == oscad::NodeKind::Assignment) {
-            assignNodes.push_back(c.get());
+            assignNodes.push_back(c);
         } else if (c->kind() != oscad::NodeKind::ModuleDeclaration && c->kind() != oscad::NodeKind::FunctionDeclaration) {
-            geoNodes.push_back(c.get());
+            geoNodes.push_back(c);
         }
     }
     if (!assignNodes.empty()) ev.evalChildren(assignNodes, effCtx);
@@ -101,8 +107,7 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
         ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, effCtx);
-        const size_t after = ev.currentTreeFrameSize();
-        groupSizes.push_back(Value{static_cast<double>(after - before)});
+        groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
     }
 
     CSGParams params;