openscad-cpp-evaluator 0.13.5__tar.gz → 0.13.9__tar.gz

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/PKG-INFO

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

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -104,18 +104,29 @@ enum class Op {
     // themselves lists).
     AccumMergeEach,
 
-    // ListCompFor's per-assignment iteration -- materialize once (a
-    // dimension's own RHS expression is evaluated exactly once, matching
-    // the interpreter's own upfront `pairs.push_back(...)` loop), then
-    // reset+iterate however many times that dimension is (re-)entered
-    // (once per outer-dimension iteration for a nested `for`). `a` = an
-    // iterList id (see CompiledChunk::numIterLists), unique per assignment
-    // across the whole chunk.
+    // ListCompFor's per-assignment iteration. `a` = an iterList id (see
+    // CompiledChunk::numIterLists), unique per assignment across the whole
+    // chunk. Each dimension's own IterMaterialize is emitted INSIDE the
+    // enclosing dimension's own loop body (compileListElement's own
+    // emitDim recursion), so it re-executes once per outer-dimension
+    // binding -- required for a later dimension's own RHS to see an
+    // earlier one's current value (e.g. `[for (p=[1:N], pt=f(p)) pt]`),
+    // matching evalFor's own doc comment (stmt_eval.cpp) and real
+    // OpenSCAD.app's verified behavior.
     IterMaterialize, // pops one Value (the assignment's RHS), expandIterable()s it into iterLists[a], resets its index
-    IterReset,       // resets iterLists[a]'s index to 0 WITHOUT re-materializing (a re-entry, not the first entry)
+    // Resets iterLists[a]'s index to 0 WITHOUT re-materializing. UNREACHABLE
+    // as of the materialize-inside-the-nesting fix above: re-materializing
+    // on every dimension re-entry already resets the index as a side
+    // effect (see IterMaterialize's own doc comment), so there's no longer
+    // a "reset without re-materializing" case left to reach for either
+    // ListCompFor (compileListElement) or ModularFor (compileForLoop).
+    // Left defined rather than removed in the same change -- a distinct,
+    // lower-risk cleanup (same convention as LoadUpvalue's own doc
+    // comment, above).
+    IterReset,
     IterNext,        // a = loop-variable slot, b = iterList id, c = jump target for exhaustion: if iterLists[b] has a
                      // next value (at its current index), write it to slots[a], advance the index, fall through;
-                     // else jump to c (index is left as-is; the next IterReset for this id will restart it)
+                     // else jump to c (index is left as-is; the next IterMaterialize for this id will restart it)
 
     // ListCompCFor's runaway-loop guard, mirroring evalListElement's own
     // 1,000,000-iteration safety limit exactly (see its own doc comment
@@ -261,7 +272,9 @@ enum class Op {
     CallModule,
 
     // -- Builtin-wrap compilation (closes the "NativeStatement gap" for ----
-    // -- translate/rotate/scale/mirror/multmatrix/resize/color/#/%/!) ------
+    // -- translate/rotate/scale/mirror/multmatrix/resize/color/#/%/!, ------
+    // -- hull/minkowski/render/linear_extrude/rotate_extrude/projection/ ---
+    // -- offset/roof) --------------------------------------------------------
     // A builtin-with-children statement that isn't a "call" the way
     // Op::CallModule's target is (no callStack_/profiling participation,
     // no named scope with upvalue semantics -- see CompiledChunk::
@@ -284,31 +297,41 @@ enum class Op {
     // (mirrors Evaluator::buildTreeNode's own ordering exactly -- doing
     // this AFTER would silently drop uncacheable/ManifoldCache taint
     // tracking for a rands() call embedded in the wrapper's own
-    // arguments), computes this site's own params (and, for Transform/
-    // Color kinds, a possibly-$-scoped child EvalContext, pushed onto
-    // f.ctxChain unconditionally -- Modifier kind needs neither params
-    // nor a ctx push), pushes a fresh ev.treeStack_ frame, and stashes
-    // {params, randsBefore, siteIdx} onto VmFrame::builtinWrapStack (a
-    // real per-frame LIFO stack, not a single slot: Push/PopBuiltinWrap
-    // pairs can nest or sequence within one frame's own instruction
-    // stream, e.g. `translate(a) translate(b) recur();`). The compiler
-    // always emits a plain Op::CheckDebugStatement immediately before
-    // this (see emitBuiltinWrap, bytecode_compiler.cpp), mirroring
-    // ModularEcho/ModularAssert's own pattern -- NOT skipped the way
-    // Op::CallModule's own call site skips one: this is a genuine
-    // statement doing real work here, unlike a module call (which
-    // transfers control to a declaration whose OWN body statements each
-    // get their own check instead).
+    // arguments), computes this site's own params for every kind except
+    // Modifier (empty, no ctx push) and Roof (deferred to Pop -- see
+    // BuiltinWrapSite's own doc comment) via that kind's own native
+    // compute function (computeTransformParams/computeColorParams/etc.,
+    // builtins.hpp) -- always a possibly-$-scoped child EvalContext,
+    // pushed onto f.ctxChain unconditionally for every non-Modifier kind
+    // (Roof pushes it too, params or not) -- pushes a fresh ev.treeStack_
+    // frame, and stashes {params, randsBefore, siteIdx, (Roof only)
+    // deferredArgs} onto VmFrame::builtinWrapStack (a real per-frame LIFO
+    // stack, not a single slot: Push/PopBuiltinWrap pairs can nest or
+    // sequence within one frame's own instruction stream, e.g.
+    // `translate(a) translate(b) recur();`). The compiler always emits a
+    // plain Op::CheckDebugStatement immediately before this (see
+    // emitBuiltinWrap, bytecode_compiler.cpp), mirroring ModularEcho/
+    // ModularAssert's own pattern -- NOT skipped the way Op::CallModule's
+    // own call site skips one: this is a genuine statement doing real
+    // work here, unlike a module call (which transfers control to a
+    // declaration whose OWN body statements each get their own check
+    // instead).
     PushBuiltinWrap,
 
     // Closes the matching Op::PushBuiltinWrap bracket: pops
     // VmFrame::builtinWrapStack's own top entry FIRST (before anything
     // that can itself throw, e.g. Evaluator::setTreeDepthOrThrow below --
     // so the exception-teardown path's own pending count is already
-    // correct if THIS throws), pops the ctx push Push made (Transform/
-    // Color kinds only), pops ev.treeStack_ to retrieve the children this
-    // bracket's own body produced, and builds the tagged CSGNode exactly
-    // like Evaluator::buildTreeNode's own post-resolveBody() half does
+    // correct if THIS throws); for Roof only, computes `pending.params`
+    // HERE via computeRoofParams(ev, pending.deferredArgs, ctx) -- the one
+    // kind whose params computation has an observable side effect
+    // (ev.warn()) that must stay ordered AFTER children, unlike every
+    // other kind's params (computed at Push, before children, since
+    // nothing else in this group has an order-sensitive side effect); pops
+    // the ctx Push made (every kind except Modifier); pops ev.treeStack_
+    // to retrieve the children this bracket's own body produced, and
+    // builds the tagged CSGNode exactly like Evaluator::buildTreeNode's
+    // own post-resolveBody() half does
     // (kind/node/isBuiltin=true/children/params/uncacheable/
     // setTreeDepthOrThrow), pushing it onto the new top of treeStack_. a
     // = index into CompiledChunk::builtinWrapSites (same site Push used).
@@ -327,7 +350,7 @@ enum class Op {
 
     // -- CSG-wrap compilation (closes the LAST native-reentry source in ----
     // -- the original NativeStatement gap: union()/difference()/           -
-    // -- intersection()) ----------------------------------------------------
+    // -- intersection()/intersection_for) -----------------------------------
     // union()/difference()/intersection() weren't covered by the original
     // Op::PushBuiltinWrap (see that op's own doc comment) because they need
     // bespoke bookkeeping PushBuiltinWrap's single all-children bracket
@@ -350,24 +373,30 @@ enum class Op {
     //
     // a = index into CompiledChunk::csgWrapSites. Runtime handler: captures
     // ev.randsCallCount() BEFORE argument resolution (same rands-in-args
-    // taint reasoning as PushBuiltinWrap), resolves the (rare, $-only)
-    // arguments via resolveCallArgs exactly like resolveCsg itself does
-    // (discarding the positional/named result -- union/difference/
-    // intersection take no real parameters -- keeping only the possibly-
-    // $-scoped child ctx), pushes that ctx onto f.ctxChain unconditionally
-    // (mirrors Transform/Color's own unconditional push -- a bare
-    // `union() {...}` with no `$fn=...` override still pushes a ctx that's
-    // merely a copy, cheap and uniform rather than a special-cased branch),
-    // pushes a fresh ev.treeStack_ frame (every child statement's own
-    // CSGNode(s), across every group, land flat in this ONE frame --
-    // mirrors Evaluator::buildTreeNode/evalModularCall's own single
-    // treeStack_.emplace_back() around the whole call, not one per group),
-    // and stashes {op, randsBefore, siteIdx, empty groupSizes} onto
-    // VmFrame::csgWrapStack (a real per-frame LIFO, same reasoning as
-    // builtinWrapStack: nested/sequenced CSG wraps within one frame's own
-    // instruction stream, e.g. `union() { difference() {...} }`). The
-    // compiler always emits a plain Op::CheckDebugStatement immediately
-    // before this (see emitCsgWrap, bytecode_compiler.cpp), mirroring
+    // taint reasoning as PushBuiltinWrap); for a `hasArgs` site (union/
+    // difference/intersection) resolves the (rare, $-only) arguments via
+    // resolveCallArgs exactly like resolveCsg itself does (discarding the
+    // positional/named result -- these take no real parameters -- keeping
+    // only the possibly-$-scoped child ctx) and pushes that ctx onto
+    // f.ctxChain unconditionally (mirrors Transform/Color's own
+    // unconditional push -- a bare `union() {...}` with no `$fn=...`
+    // override still pushes a ctx that's merely a copy, cheap and uniform
+    // rather than a special-cased branch); intersection_for (`hasArgs`
+    // false -- it isn't a call, has no `.arguments`) skips both entirely,
+    // matching resolveIntersectionFor's own use of its caller's ctx
+    // unchanged (its per-ITERATION child ctxs are a completely separate
+    // concern, handled by the compiled cartesian loop's own Op::
+    // ForIterNext, not by this bracket). Either way: pushes a fresh
+    // ev.treeStack_ frame (every child statement's/iteration's own
+    // CSGNode(s) land flat in this ONE frame -- mirrors Evaluator::
+    // buildTreeNode/evalModularCall's own single treeStack_.emplace_back()
+    // around the whole call, not one per group), and stashes {op,
+    // randsBefore, siteIdx, empty groupSizes} onto VmFrame::csgWrapStack (a
+    // real per-frame LIFO, same reasoning as builtinWrapStack: nested/
+    // sequenced CSG wraps within one frame's own instruction stream, e.g.
+    // `union() { difference() {...} }`). The compiler always emits a plain
+    // Op::CheckDebugStatement immediately before this (see emitCsgWrap/
+    // compileIntersectionForLoop, bytecode_compiler.cpp), mirroring
     // emitBuiltinWrap's own pattern -- this is a genuine statement doing
     // real work here, not a call transferring control to a declaration.
     PushCsgWrap,
@@ -401,14 +430,19 @@ enum class Op {
     // VmFrame::csgWrapStack's own top entry FIRST (before anything that can
     // itself throw, e.g. setTreeDepthOrThrow below -- same "exception-
     // teardown's own pending count must already be right" reasoning as
-    // PopBuiltinWrap), pops the ctx PushCsgWrap unconditionally pushed,
+    // PopBuiltinWrap), pops the ctx Push pushed (only when `hasArgs`),
     // pops ev.treeStack_ to retrieve every group's own CSGNode(s) (flat,
     // exactly like resolveCsg's own `children` result -- group boundaries
     // live only in group_sizes, never in the CSGNode list's own shape), and
     // builds the tagged CSGNode exactly like Evaluator::buildTreeNode's own
-    // post-resolveBody() half does, with params = {"op": site.op,
-    // "group_sizes": ValueList(pending.groupSizes)} -- byte-for-byte what
-    // native resolveCsg returns -- pushing the result onto the new top of
+    // post-resolveBody() half does, with params = {"group_sizes":
+    // ValueList(pending.groupSizes)} plus, only when `includeOpParam`,
+    // "op": site.op -- byte-for-byte what native resolveCsg returns for
+    // union/difference/intersection (generateCsg needs "op" to
+    // disambiguate the ONE function it shares across all 3) and what
+    // native resolveIntersectionFor returns (no "op" key at all --
+    // generateIntersectionFor is its own dedicated, separately-registered
+    // function, never needs one) -- pushing the result onto the new top of
     // treeStack_. a = index into CompiledChunk::csgWrapSites (same site
     // Push used).
     //
@@ -462,33 +496,49 @@ enum class Op {
     // no separate site table needed).
     CallChildren,
 
-    // A single "native passthrough" statement -- intersection_for, every
-    // OTHER builtin module call not covered by Op::PushBuiltinWrap/
-    // Op::PushCsgWrap (see those ops' own doc comments for exactly which
-    // builtins ARE covered -- cube/sphere/hull/linear_extrude/etc., the
-    // ones that never wrap a recursive call in idiomatic OpenSCAD), the `*`
-    // modifier's own no-op case, or a user-module call that didn't
-    // resolve at compile time (shadowed, forward-declared, or otherwise
-    // not statically known) -- anything compileStatementList doesn't give
-    // its own real bytecode. (Assignment/ModularEcho/ModularAssert/
-    // ModularLet used to fall here too; they now have their own real
-    // bytecode -- Op::StoreModuleVar/Op::Echo/Op::AssertStatement/
-    // Op::OpenLetScope+StoreLetVar -- purely a throughput change, since
-    // none of these were ever the recursion-depth risk this compiler
-    // targets. `#`/`%`/`!` modifiers and translate/rotate/scale/mirror/
-    // multmatrix/resize/color used to fall here too, for the SAME
-    // throughput reasoning -- WRONG in that one specific case: a
-    // recursive module call wrapped in one of these is exactly the
-    // pattern that made this op's own native reentry a genuine Windows
-    // crash risk in practice, not just a missed optimization. See
-    // Op::PushBuiltinWrap's own doc comment for the real story and the
-    // fix. children() fell here too, and was the LAST and largest such
-    // reentry source once PushBuiltinWrap's own set was covered -- it now
-    // has Op::CallChildren, above. union()/difference()/intersection()
-    // fell here too, and were the last remaining REAL native-reentry risk
-    // (bespoke group_sizes bookkeeping meant they couldn't just reuse
+    // A single "native passthrough" statement -- every builtin module call
+    // not covered by Op::PushBuiltinWrap/Op::PushCsgWrap (see those ops'
+    // own doc comments for exactly which builtins ARE covered -- cube/
+    // sphere/import/text/surface/etc., the true LEAVES that never take a
+    // `children` block at all, so wrapping a recursive call inside one
+    // isn't even syntactically possible), the `*` modifier's own no-op
+    // case, or a user-module call that didn't resolve at compile time
+    // (shadowed, forward-declared, or otherwise not statically known) --
+    // anything compileStatementList doesn't give its own real bytecode.
+    // (Assignment/ModularEcho/ModularAssert/ModularLet used to fall here
+    // too; they now have their own real bytecode -- Op::StoreModuleVar/
+    // Op::Echo/Op::AssertStatement/Op::OpenLetScope+StoreLetVar -- purely
+    // a throughput change, since none of these were ever the recursion-
+    // depth risk this compiler targets. `#`/`%`/`!` modifiers and
+    // translate/rotate/scale/mirror/multmatrix/resize/color used to fall
+    // here too, for the SAME throughput reasoning -- WRONG in that one
+    // specific case: a recursive module call wrapped in one of these is
+    // exactly the pattern that made this op's own native reentry a
+    // genuine Windows crash risk in practice, not just a missed
+    // optimization. See Op::PushBuiltinWrap's own doc comment for the
+    // real story and the fix. children() fell here too, and was the LAST
+    // and largest such reentry source once PushBuiltinWrap's own set was
+    // covered -- it now has Op::CallChildren, above. union()/difference()/
+    // intersection() fell here too, and were the last remaining REAL
+    // native-reentry risk among ModularCall-shaped statements (bespoke
+    // group_sizes bookkeeping meant they couldn't just reuse
     // PushBuiltinWrap's own bracket) -- they now have Op::PushCsgWrap,
-    // above.)
+    // above. hull()/minkowski()/render()/linear_extrude()/rotate_extrude()/
+    // projection()/offset()/roof() fell here too, closing out every
+    // remaining non-leaf builtin whose OWN children can wrap a recursive
+    // call in an idiomatic script (a rounded-hull chain, a recursive
+    // extrude, etc.) -- they now share Op::PushBuiltinWrap's own bracket
+    // via 6 new Kind values (Passthrough/LinearExtrude/RotateExtrude/
+    // Projection/Offset/Roof), reusing the exact same mechanism rather
+    // than inventing another. intersection_for -- NOT a ModularCall at
+    // all, its own NodeKind -- fell here too and was the true LAST
+    // native-reentry gap; it now shares Op::PushCsgWrap's own bracket
+    // (CsgWrapSite::hasArgs/includeOpParam both false for it) wrapped
+    // around a compiled cartesian-product loop reusing Op::ForIterNext/
+    // ForIterEnd/NativeIterMaterialize verbatim (see
+    // compileIntersectionForLoop, bytecode_compiler.cpp) -- one Op::
+    // CsgGroupStart/CsgGroupEnd pair per full iteration instead of per
+    // source statement. Every non-leaf builtin construct is covered now.)
     // a = index into CompiledChunk::nativeStatements. Runtime just does
     // what Evaluator::evalChildren's own per-statement loop already does
     // for one node: derive childCtx via ctx.withScope(...), checkDebug,
@@ -813,8 +863,8 @@ struct CompiledChunk {
     // replay the native param-resolution step and rebuild the tagged
     // CSGNode at Pop time.
     //
-    // `node`'s concrete type depends on `kind`: Transform/Color sites are
-    // genuine `ModularCall`s (down-cast to read `.name`/`.arguments`/
+    // `node`'s concrete type depends on `kind`: every kind except Modifier
+    // is a genuine `ModularCall` (down-cast to read `.name`/`.arguments`/
     // `.children`); Modifier sites are the wrapper node itself
     // (`ModularModifierHighlight`/`Background`/`ShowOnly` -- `!`/`#`/`%`;
     // `*`/Disable never reaches here, its child never evaluates at all,
@@ -826,24 +876,60 @@ struct CompiledChunk {
     // union of concrete pointers) because that's all Op::PopBuiltinWrap
     // itself ever needs `node` for: the resulting CSGNode's own
     // `node`/error-position field.
+    //
+    // Passthrough/LinearExtrude/RotateExtrude/Projection/Offset/Roof
+    // (added for hull()/minkowski()/render()/linear_extrude()/
+    // rotate_extrude()/projection()/offset()/roof()) share Transform/
+    // Color's exact push-time-computed-params shape, just via a different
+    // native compute function each (Op::PushBuiltinWrap's own runtime
+    // handler switches on `kind` to pick it) -- see that op's own doc
+    // comment for the one exception (Roof, whose params computation has
+    // to run at POP time instead, after children, to preserve an
+    // observable warn() ordering).
     struct BuiltinWrapSite {
-        enum class Kind { Transform, Color, Modifier };
+        enum class Kind {
+            Transform,
+            Color,
+            Modifier,
+            Passthrough,   // hull()/minkowski()/render() -- empty params, no compute function needed
+            LinearExtrude,
+            RotateExtrude,
+            Projection,
+            Offset,
+            Roof,          // computed at POP time, not PUSH -- see this struct's own doc comment
+        };
         Kind kind;
-        std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"
+        std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"/"hull"/...
         const oscad::ASTNode* node = nullptr;
     };
 
     // One Op::PushCsgWrap/PopCsgWrap site pair -- see those ops' own doc
     // comments for the full "why union/difference/intersection need
     // bespoke group_sizes bookkeeping instead of just reusing
-    // BuiltinWrapSite" rationale. `op` is always "union"/"difference"/
-    // "intersection" (the only 3 names resolveDispatch() maps to
-    // resolveCsg) -- always a genuine ModularCall (unlike BuiltinWrapSite's
-    // Modifier kind, this construct has no non-ModularCall variant), so
-    // `node` is typed precisely rather than a generic ASTNode*.
+    // BuiltinWrapSite" rationale. `op` is "union"/"difference"/
+    // "intersection" (the 3 names resolveDispatch() maps to resolveCsg,
+    // always a genuine ModularCall) OR "intersection_for" (NOT a
+    // ModularCall -- a distinct NodeKind/ModuleInstantiation subtype with
+    // its own `.assignments`/`.body`, see compileIntersectionForLoop,
+    // bytecode_compiler.cpp) -- `node` is therefore the generic ASTNode*
+    // BuiltinWrapSite's own Modifier kind already established this pattern
+    // for, down-cast to ModularCall only when `hasArgs` is true.
+    //
+    // `hasArgs`/`includeOpParam` are both true for union/difference/
+    // intersection, both false for intersection_for: it isn't a call at
+    // all (no `.arguments`, so Op::PushCsgWrap's handler must skip
+    // resolveCallArgs/the ctx push entirely -- matches native
+    // resolveIntersectionFor, which uses the SAME ctx its caller passed in
+    // unchanged, never a $-scoped child of its own), and its own
+    // CSGParams has no "op" key at all (generateIntersectionFor is a
+    // dedicated, separately-registered generate function, unlike
+    // generateCsg which needs "op" in params to disambiguate union/
+    // difference/intersection from ONE shared function).
     struct CsgWrapSite {
         std::string op;
-        const oscad::ModularCall* node = nullptr;
+        bool hasArgs = true;
+        bool includeOpParam = true;
+        const oscad::ASTNode* node = nullptr;
     };
 
     // One Op::AssertStatement site -- see that op's own doc comment for

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -2,6 +2,7 @@
 
 #include "openscad_cpp_evaluator/bound_args.hpp"
 #include "openscad_cpp_evaluator/bytecode.hpp"
+#include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/csg_node.hpp"
 #include "openscad_cpp_evaluator/eval_context.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
@@ -28,6 +29,15 @@ struct PendingBuiltinWrap {
     CSGParams params;
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
+    // Only populated for BuiltinWrapSite::Kind::Roof -- the already-
+    // resolved call arguments, retained across the whole bracket so
+    // Op::PopBuiltinWrap's handler can compute roof()'s own params AFTER
+    // children finish (computeRoofParams needs them; re-running
+    // resolveCallArgs at Pop time instead would re-evaluate every argument
+    // expression a second time -- double rands()/side effects). Every
+    // other kind computes its params at Push time and leaves this default-
+    // empty.
+    CallArgs deferredArgs;
 };
 
 // One still-open Op::PushCsgWrap bracket's own state -- see that op's own

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/pyproject.toml

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

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/src/builtins/builtins.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/dispatch.hpp"
 
 #include <optional>
@@ -153,21 +154,30 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams& param
                                             const oscad::ASTNode& node);
 
 // linear_extrude()/rotate_extrude()/projection() -- extrude.cpp.
+// computeXParams: the pure "resolve args, build params" half, split out
+// like computeTransformParams/computeColorParams so Op::PushBuiltinWrap's
+// own runtime handler can call it directly (bytecode_vm.cpp) instead of
+// through the whole resolve function, whose OTHER half (evalChildren) is
+// exactly the native reentry that split exists to avoid.
+BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveLinearExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& params,
                                                 const std::vector<std::unique_ptr<CSGNode>>& children,
                                                 const oscad::ASTNode& node);
 
+BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveRotateExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& params,
                                                 const std::vector<std::unique_ptr<CSGNode>>& children,
                                                 const oscad::ASTNode& node);
 
+BuiltinWrapParams computeProjectionParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveProjection(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateProjection(Evaluator& ev, const CSGParams& params,
                                              const std::vector<std::unique_ptr<CSGNode>>& children,
                                              const oscad::ASTNode& node);
 
+BuiltinWrapParams computeOffsetParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
                                          const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
@@ -176,6 +186,13 @@ std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
 // contour polygons) + Tier 3 (SDF/level-set fallback) only, per the plan --
 // Tier 2 (general multi-contour/hole straight skeleton) is a named,
 // documented follow-up, not silently dropped (see CLAUDE.md).
+// computeRoofParams: UNLIKE computeLinearExtrudeParams and friends above,
+// this is the params-computation half taken from AFTER evalChildren (it
+// calls ev.warn(), an observable side effect that must stay ordered after
+// any child's own echo/warn output) -- takes already-resolved CallArgs,
+// not a raw node+ctx, since Op::PushBuiltinWrap's own runtime handler
+// calls this at POP time. See its own doc comment (roof.cpp).
+CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx);
 CSGParams resolveRoof(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateRoof(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/src/builtins/control.cpp

@@ -97,24 +97,21 @@ ColoredBody combineBodies(const std::vector<ColoredBody>& bodies) {
 // children) -- same rationale as booleans.cpp's own group_sizes. Mirrors
 // _resolve_intersection_for/_generate_intersection_for.
 CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersectionFor& node, EvalContext& ctx) {
-    std::vector<std::pair<std::string, IterableValues>> varSeqs;
-    varSeqs.reserve(node.assignments.size());
-    for (const auto& assign : node.assignments) {
-        Value values = ev.evalExpr(*assign->expr, ctx);
-        const oscad::Position* pos = &assign->position();
-        varSeqs.emplace_back(assign->name->name, expandIterable(values, [&](size_t count) {
-            ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
-        }));
-    }
-
     std::vector<const oscad::ASTNode*> bodyNodes;
     bodyNodes.reserve(node.body.size());
     for (const auto& b : node.body) bodyNodes.push_back(b.get());
 
     std::vector<Value> groupSizes;
 
+    // Each dimension's own RHS is evaluated against `parentCtx` (not
+    // upfront against the original `ctx`), re-evaluated on every entry
+    // into this recursion level -- see evalFor's own doc comment
+    // (stmt_eval.cpp) for the full "verified against real OpenSCAD.app"
+    // rationale; this is the identical bug in intersection_for's own
+    // cartesian loop (e.g. `intersection_for (i=[0:2], j=[0:i]) ...`
+    // needs `i` visible in `j`'s own range expression).
     std::function<void(size_t, EvalContext&)> recurse = [&](size_t depth, EvalContext& parentCtx) {
-        if (depth == varSeqs.size()) {
+        if (depth == node.assignments.size()) {
             // One body-entry marker per full cartesian-product iteration
             // and nothing per individual variable binding (unlike
             // evalFor) -- mirrors _resolve_intersection_for's single
@@ -126,9 +123,15 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
             groupSizes.push_back(Value{static_cast<double>(after - before)});
             return;
         }
-        for (const Value& val : varSeqs[depth].second) {
+        const auto& assign = node.assignments[depth];
+        Value values = ev.evalExpr(*assign->expr, parentCtx);
+        const oscad::Position* pos = &assign->position();
+        IterableValues iter = expandIterable(values, [&](size_t count) {
+            ev.warn("Bad range parameter in for statement: too many elements (" + std::to_string(count) + ")", pos);
+        });
+        for (const Value& val : iter) {
             EvalContext childCtx = parentCtx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);
-            childCtx.let_->set(varSeqs[depth].first, val);
+            childCtx.let_->set(assign->name->name, val);
             recurse(depth + 1, childCtx);
         }
     };

{openscad_cpp_evaluator-0.13.5 → openscad_cpp_evaluator-0.13.9}/src/builtins/extrude.cpp

@@ -13,10 +13,21 @@ namespace oscadeval {
 // mirrors _resolve_linear_extrude/_generate_linear_extrude. `scale` is
 // either a single number (applied to both X/Y) or a [x,y] pair for the top
 // face; the bottom face is always full-size.
-
-CSGParams resolveLinearExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+//
+// Split into computeLinearExtrudeParams (pure, no children-evaluation side
+// effect) + resolveLinearExtrude (adds the evalChildren call) so Op::
+// PushBuiltinWrap's own runtime handler (bytecode_vm.cpp) can call the pure
+// half directly instead of going through the whole resolve function --
+// exactly the same split computeTransformParams/computeColorParams already
+// use, extended to this builtin. Params computation here has no observable
+// side effect of its own (no warn()/echo()/rands() call), so moving it
+// before evalChildren (unlike this function's own former single-body
+// shape, which computed params AFTER children like every other builtin
+// still not covered by PushBuiltinWrap) is behaviorally unobservable --
+// see computeRoofParams's own doc comment (roof.cpp) for the one builtin
+// in this group where that ISN'T true and a different split was needed.
+BuiltinWrapParams computeLinearExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    ev.evalChildren(node.children, effCtx);
 
     const double height = toDoubleLenient(getArg(args, 0, "height", Value{1.0}));
     const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
@@ -40,7 +51,13 @@ CSGParams resolveLinearExtrude(Evaluator& ev, const oscad::ModularCall& node, Ev
     params["scale_x"] = Value{scaleX};
     params["scale_y"] = Value{scaleY};
     params["color"] = colorToValue(effCtx.color);
-    return params;
+    return BuiltinWrapParams{std::move(params), std::move(effCtx)};
+}
+
+CSGParams resolveLinearExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeLinearExtrudeParams(ev, node, ctx);
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& params,
@@ -65,9 +82,10 @@ std::vector<ColoredBody> generateLinearExtrude(Evaluator& ev, const CSGParams& p
 // so resolve only caches $fn/$fa/$fs for generate to call fnSegments()
 // with once the real max-x bound exists.
 
-CSGParams resolveRotateExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+// Split the same way as computeLinearExtrudeParams, above -- see its own
+// doc comment.
+BuiltinWrapParams computeRotateExtrudeParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    ev.evalChildren(node.children, effCtx);
 
     const double angle = toDoubleLenient(getArg(args, 0, "angle", Value{360.0}));
 
@@ -84,7 +102,13 @@ CSGParams resolveRotateExtrude(Evaluator& ev, const oscad::ModularCall& node, Ev
     params["fa"] = Value{dynOr("$fa", 12.0)};
     params["fs"] = Value{dynOr("$fs", 2.0)};
     params["color"] = colorToValue(effCtx.color);
-    return params;
+    return BuiltinWrapParams{std::move(params), std::move(effCtx)};
+}
+
+CSGParams resolveRotateExtrude(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeRotateExtrudeParams(ev, node, ctx);
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& params,
@@ -108,12 +132,19 @@ std::vector<ColoredBody> generateRotateExtrude(Evaluator& ev, const CSGParams& p
 // FillRule::Positive to clean up self-intersections Manifold's own
 // Project() can produce.
 
-CSGParams resolveProjection(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+// Split the same way as computeLinearExtrudeParams, above -- see its own
+// doc comment.
+BuiltinWrapParams computeProjectionParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    ev.evalChildren(node.children, effCtx);
     CSGParams params;
     params["cut"] = Value{truthy(getArg(args, std::nullopt, "cut", Value{false}))};
-    return params;
+    return BuiltinWrapParams{std::move(params), std::move(effCtx)};
+}
+
+CSGParams resolveProjection(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeProjectionParams(ev, node, ctx);
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
@@ -145,9 +176,10 @@ std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
 // (JoinType::Square, or Miter if chamfer=true) are mutually exclusive;
 // neither given passes the first child through unchanged.
 
-CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+// Split the same way as computeLinearExtrudeParams, above -- see its own
+// doc comment.
+BuiltinWrapParams computeOffsetParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
-    ev.evalChildren(node.children, effCtx);
 
     const Value rArg = getArg(args, std::nullopt, "r", Value{});
     const Value deltaArg = getArg(args, std::nullopt, "delta", Value{});
@@ -161,7 +193,13 @@ CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalConte
         params["segs"] = Value{static_cast<double>(fnSegmentsFromCtx(effCtx, std::fabs(toDoubleLenient(rArg))))};
     }
     params["color"] = colorToValue(effCtx.color);
-    return params;
+    return BuiltinWrapParams{std::move(params), std::move(effCtx)};
+}
+
+CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    BuiltinWrapParams result = computeOffsetParams(ev, node, ctx);
+    ev.evalChildren(node.children, result.ctx);
+    return std::move(result.params);
 }
 
 std::vector<ColoredBody> generateOffset(Evaluator&, const CSGParams& params, const std::vector<std::unique_ptr<CSGNode>>& children,