openscad-cpp-evaluator 1.0.1__tar.gz → 1.2.0__tar.gz

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/.github/workflows/wheels.yml

@@ -165,9 +165,13 @@ jobs:
   publish-pypi:
     needs: [publish-testpypi]
     runs-on: ubuntu-latest
-    # Requires a "pypi" GitHub Environment with a required-reviewer
-    # protection rule, so this job pauses for manual approval after the
-    # TestPyPI publish above has been verified.
+    # The "pypi" environment carries no protection rules, so a tag runs
+    # straight through TestPyPI to PyPI with nothing to stop it -- and a
+    # PyPI upload cannot be undone or replaced at the same version. Adding
+    # a required reviewer to the environment reinstates that brake; GitHub
+    # permits approving your own deployment unless "Prevent self-review"
+    # is ticked. Kept regardless of rules: token auth aside, the
+    # environment is where a publishing credential would be scoped.
     environment: pypi
     steps:
       - uses: actions/download-artifact@v8

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/bindings/module.cpp

@@ -373,7 +373,8 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
 }
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
-                     std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile) {
+                     std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
+                     bool generate) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -391,9 +392,12 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
             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));
+            bodies = oscadeval::toRenderableBodies(ev.evaluate(used.processedNodes, ctx, vp, generate));
             collectIdSpans(ev, idSpans);
-            csgTree = std::move(ev.csgTree);
+            // Only moved out when it will actually be converted below --
+            // csgTreeToPy() walks the whole tree building Python objects,
+            // which a resolve-only caller has no use for.
+            if (generate) csgTree = std::move(ev.csgTree);
             profileResult = std::move(ev.profileResult);
             {
                 nb::gil_scoped_acquire g; // building Python objects needs the GIL back
@@ -792,8 +796,11 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "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).");
+          nb::arg("profile") = false, nb::arg("generate") = true,
+          "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).\n"
+          "generate=False stops after the resolve pass: the script runs and reports everything "
+          "it normally would, but no Manifold geometry is built, and neither bodies nor csg_tree "
+          "are populated.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -178,15 +178,24 @@ public:
     // forcing it to expose a separate `_root_ctx` escape hatch for this)
     // this port's `ctx` is always caller-owned already. Mirrors the
     // reference's `evaluate(nodes, root_scope, viewport_params=None)`.
+    //
+    // `generate = false` stops after the resolve pass: the CSG tree is built
+    // and stashed in `csgTree` as usual, but no Manifold work happens and an
+    // empty body list comes back. For a caller that only wants to know
+    // whether a script RUNS -- a docs check, a syntax/semantics smoke test --
+    // that skips the geometry without skipping the language. Mirrors what the
+    // reference does for `openscad -o out.term`.
     std::vector<ColoredBody> evaluate(const std::vector<std::unique_ptr<oscad::ASTNode>>& nodes, EvalContext& ctx,
-                                       const std::unordered_map<std::string, Value>& viewportParams = {});
+                                       const std::unordered_map<std::string, Value>& viewportParams = {},
+                                       bool generate = true);
     // Same, but over a non-owning pointer list -- needed by `use <file>`
     // resolution (eval_use.hpp/.cpp), whose "processed nodes" list combines
     // declarations owned by more than one independently-owned AST vector,
     // so it can't be represented as a single vector<unique_ptr<ASTNode>>.
     // Mirrors evalChildren's existing dual-overload shape.
     std::vector<ColoredBody> evaluate(const std::vector<const oscad::ASTNode*>& nodes, EvalContext& ctx,
-                                       const std::unordered_map<std::string, Value>& viewportParams = {});
+                                       const std::unordered_map<std::string, Value>& viewportParams = {},
+                                       bool generate = true);
 
     // Resolve pass: resets idToNode/idToColor and the tree-build stack,
     // then walks `nodes` via evalChildren(), returning the completed (but
@@ -654,7 +663,8 @@ private:
     std::vector<std::unique_ptr<CSGNode>> resolveTreeImpl(const NodeList& nodes, EvalContext& ctx);
     template <typename NodeList>
     std::vector<ColoredBody> evaluateImpl(const NodeList& nodes, EvalContext& ctx,
-                                           const std::unordered_map<std::string, Value>& viewportParams);
+                                           const std::unordered_map<std::string, Value>& viewportParams,
+                                           bool generate);
 
     // Shared bottom-up generate walk behind generateTree()/generatePartialTree()
     // -- see generatePartialTree()'s own doc comment and this function's

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/python/openscad_cpp_evaluator/__init__.py

@@ -492,7 +492,19 @@ class Evaluator:
         self.dyn = {}
         self.dyn_explicit = set()
 
-    def evaluate(self, source_path: str, viewport_params: Optional[dict] = None):
+    def evaluate(self, source_path: str, viewport_params: Optional[dict] = None,
+                 generate: bool = True):
+        """Run `source_path` and return (bodies, id_to_node).
+
+        `generate=False` stops after the resolve pass. The script still runs
+        in full, so everything it echoes, warns or errors about is reported
+        exactly as usual -- but no Manifold geometry is built, and `bodies`
+        and `csg_tree` both come back empty. For a caller that only wants to
+        know whether a script RUNS (a docs check, a smoke test) that skips
+        the geometry without skipping the language.
+
+        Ignored on the debugger path, which has no geometry handle anyway.
+        """
         vp = viewport_params or {}
         try:
             if self._debug_hook is not None:
@@ -512,7 +524,7 @@ class Evaluator:
             else:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry) = _ext.evaluate(
-                    source_path, vp, self._manifold_cache, self._profile)
+                    source_path, vp, self._manifold_cache, self._profile, generate)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/src/builtins/booleans.cpp

@@ -214,7 +214,15 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
-    std::optional<ColoredBody> csgResult;
+    // Two accumulators, one per dimension. union() may legitimately carry
+    // both -- `translate(...) { part(); text("label"); }` is how a docs
+    // figure annotates a 3D part, and the reference draws both -- and a
+    // single optional that switched between body and section is exactly
+    // what used to be dereferenced empty when a group changed dimension
+    // part-way. difference and intersection still see one dimension only:
+    // applyDimensionRules drops the mismatch before it gets here, so for
+    // them just one of these is ever populated.
+    std::optional<ColoredBody> res3d, res2d;
     size_t idx = 0;
 
     size_t stmtIndex = 0;
@@ -273,50 +281,56 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             // discards while no positive operand has been established yet;
             // union just skips the empty contributor and keeps going.
             if (op == "intersection") {
-                csgResult.reset();
+                res3d.reset();
+                res2d.reset();
                 break;
             }
-            if (op == "difference" && !csgResult) break;
+            if (op == "difference" && !res3d && !res2d) break;
             continue;
         }
 
+        // Each dimension accumulates on its own, so a statement holding
+        // both contributes to both rather than the 2D half falling off the
+        // end of an if/else.
         if (!bodies3d.empty()) {
             manifold::Manifold grp = *bodies3d.front().body;
             for (size_t i = 1; i < bodies3d.size(); ++i) grp = grp + *bodies3d[i].body;
-            if (!csgResult) {
+            if (!res3d) {
                 ColoredBody cb;
                 cb.body = std::move(grp);
                 cb.color = bodies3d.front().color;
-                csgResult = std::move(cb);
+                res3d = std::move(cb);
             } else if (op == "union") {
-                csgResult->body = *csgResult->body + grp;
+                res3d->body = *res3d->body + grp;
             } else if (op == "difference") {
-                csgResult->body = *csgResult->body - grp;
+                res3d->body = *res3d->body - grp;
             } else if (op == "intersection") {
-                csgResult->body = *csgResult->body ^ grp;
+                res3d->body = *res3d->body ^ grp;
             }
-        } else {
+        }
+        if (!sections2d.empty()) {
             manifold::CrossSection grp = *sections2d.front().section;
             for (size_t i = 1; i < sections2d.size(); ++i) grp = grp + *sections2d[i].section;
-            if (!csgResult) {
+            if (!res2d) {
                 ColoredBody cb;
                 cb.section = std::move(grp);
                 cb.color = sections2d.front().color;
-                csgResult = std::move(cb);
+                res2d = std::move(cb);
             } else if (op == "union") {
-                csgResult->section = *csgResult->section + grp;
+                res2d->section = *res2d->section + grp;
             } else if (op == "difference") {
-                csgResult->section = *csgResult->section - grp;
+                res2d->section = *res2d->section - grp;
             } else if (op == "intersection") {
-                csgResult->section = *csgResult->section ^ grp;
+                res2d->section = *res2d->section ^ grp;
             }
         }
     }
 
-    if (csgResult && csgResult->body) attachTriColors(ev, *csgResult);
+    if (res3d && res3d->body) attachTriColors(ev, *res3d);
 
     std::vector<ColoredBody> result;
-    if (csgResult) result.push_back(std::move(*csgResult));
+    if (res3d) result.push_back(std::move(*res3d));
+    if (res2d) result.push_back(std::move(*res2d));
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/src/csg_generate.cpp

@@ -129,6 +129,20 @@ enum class DimRule {
     None,    // no dimension diagnostics at all
 };
 
+// Nodes that hand their children on as a list instead of combining them
+// into one result, so a mixed 2D/3D list reaches nothing that has to pick a
+// single dimension. generateTransform and generateColor map over the
+// bodies; generateCsg's union keeps a 3D and a 2D accumulator side by side.
+//
+// difference and intersection are deliberately absent: subtracting or
+// intersecting across dimensions has no meaning, and they still collapse to
+// one result. hull and minkowski likewise build a single hull.
+bool keepsMixedDimensions(const std::string& kind) {
+    return kind == "union" || kind == "color" || kind == "translate" ||
+           kind == "rotate" || kind == "scale" || kind == "mirror" ||
+           kind == "multmatrix" || kind == "resize";
+}
+
 DimRule dimRuleFor(const std::string& kind) {
     if (kind == "linear_extrude" || kind == "rotate_extrude" || kind == "offset") return DimRule::Only2D;
     if (kind == "projection") return DimRule::Only3D;
@@ -168,7 +182,11 @@ void Evaluator::applyDimensionRules(CSGNode& node) {
     std::vector<CSGNode*> kids;
     kids.reserve(node.children.size());
     for (const std::unique_ptr<CSGNode>& c : node.children) kids.push_back(c.get());
-    applyDimensionRulesTo(kids, static_cast<int>(rule));
+    // Only a Group-rule node can keep a mix. linear_extrude and friends take
+    // one dimension by definition, so a wrong-dimension child there is still
+    // dropped with its warning.
+    const bool keepMixed = rule == DimRule::Group && keepsMixedDimensions(node.kind);
+    applyDimensionRulesTo(kids, static_cast<int>(rule), keepMixed);
 }
 
 // `keepMixed` warns about a mixed group but drops nothing -- the top level's
@@ -199,7 +217,12 @@ void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int
                 continue;
             }
             const oscad::Position* pos = child->node ? &child->node->position() : nullptr;
-            if (rule == DimRule::Group && !warnedMixing) {
+            // Silent when both are kept: the reference says nothing for
+            // `cube(1); square(4);`, `translate(...) { ... }` or `union()
+            // { ... }` -- checked by running it -- and a warning here would
+            // fail any docs example that legitimately draws a 2D annotation
+            // beside a 3D part.
+            if (rule == DimRule::Group && !keepMixed && !warnedMixing) {
                 warn("Mixing 2D and 3D objects is not supported", pos);
                 warnedMixing = true;
             }

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/src/csg_resolve.cpp

@@ -244,7 +244,8 @@ std::vector<std::unique_ptr<CSGNode>> Evaluator::resolveTree(const std::vector<c
 
 template <typename NodeList>
 std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalContext& ctx,
-                                                  const std::unordered_map<std::string, Value>& viewportParams) {
+                                                  const std::unordered_map<std::string, Value>& viewportParams,
+                                                  bool generate) {
     // Seeds ctx.dyn directly, deliberately not touching ctx.dynExplicit --
     // see this method's own doc comment in evaluator.hpp for why that
     // distinction matters to a caller.
@@ -260,7 +261,10 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     std::vector<std::unique_ptr<CSGNode>> tree = resolveTreeImpl(nodes, ctx);
     rerootAtShowOnly(tree);
     const Clock::time_point resolveEnd = profiling_ ? Clock::now() : Clock::time_point{};
-    std::vector<ColoredBody> result = generateTree(tree);
+    // generate = false is the resolve-only path: the language has run and
+    // the tree is built, so anything the script itself gets wrong has already
+    // been reported -- only the Manifold work is skipped.
+    std::vector<ColoredBody> result = generate ? generateTree(tree) : std::vector<ColoredBody>{};
     const Clock::time_point generateEnd = profiling_ ? Clock::now() : Clock::time_point{};
     csgTree = std::move(tree); // stash for caller inspection -- see the member's own doc comment
 
@@ -332,13 +336,15 @@ void Evaluator::rerootAtShowOnly(std::vector<std::unique_ptr<CSGNode>>& tree) {
 }
 
 std::vector<ColoredBody> Evaluator::evaluate(const std::vector<std::unique_ptr<oscad::ASTNode>>& nodes, EvalContext& ctx,
-                                              const std::unordered_map<std::string, Value>& viewportParams) {
-    return evaluateImpl(nodes, ctx, viewportParams);
+                                              const std::unordered_map<std::string, Value>& viewportParams,
+                                              bool generate) {
+    return evaluateImpl(nodes, ctx, viewportParams, generate);
 }
 
 std::vector<ColoredBody> Evaluator::evaluate(const std::vector<const oscad::ASTNode*>& nodes, EvalContext& ctx,
-                                              const std::unordered_map<std::string, Value>& viewportParams) {
-    return evaluateImpl(nodes, ctx, viewportParams);
+                                              const std::unordered_map<std::string, Value>& viewportParams,
+                                              bool generate) {
+    return evaluateImpl(nodes, ctx, viewportParams, generate);
 }
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/tests/test_booleans.cpp

@@ -618,41 +618,53 @@ std::vector<std::string> dimWarnings(const std::string& code) {
 }
 } // namespace
 
-TEST(MixedDimensions, ThreeDeeFirstUnionDoesNotCrash) {
-    // The regression that started this: a body-then-section group.
-    Evaluated e = evalSrc("union() { cube(1); square(4); }");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].body.has_value());
-    EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-9);
+// Both dimensions survive a union or a transform, in either order, because
+// the reference keeps both -- `translate([9,3]) { cube(10); text("hi"); }`
+// renders the cube AND the flat text there, which is how BOSL2's joiners
+// figure annotates a part. Checked by running the reference, not assumed.
+TEST(MixedDimensions, UnionKeepsBothDimensions) {
+    for (const char* src : {"union() { cube(1); square(4); }",
+                            "union() { square(4); cube(1); }"}) {
+        Evaluated e = evalSrc(src);
+        ASSERT_EQ(e.bodies.size(), 2u) << src;
+        const ColoredBody* solid = nullptr;
+        const ColoredBody* flat = nullptr;
+        for (const ColoredBody& b : e.bodies) {
+            if (b.body) solid = &b;
+            if (b.section) flat = &b;
+        }
+        ASSERT_TRUE(solid) << src;
+        ASSERT_TRUE(flat) << src;
+        EXPECT_NEAR(solid->body->Volume(), 1.0, 1e-9) << src;
+        EXPECT_NEAR(flat->section->Area(), 16.0, 1e-9) << src;
+    }
 }
 
-TEST(MixedDimensions, TwoDeeFirstKeepsTheTwoDeeChild) {
-    Evaluated e = evalSrc("union() { square(4); cube(1); }");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].section.has_value());
-    EXPECT_NEAR(e.bodies[0].section->Area(), 16.0, 1e-9);
+TEST(MixedDimensions, TransformKeepsBothDimensions) {
+    // The transform maps over its bodies rather than combining them, so the
+    // mix reaches nothing that has to choose.
+    Evaluated e = evalSrc("translate([0,0,0]) { square(4); cube(1); }");
+    ASSERT_EQ(e.bodies.size(), 2u);
 }
 
-TEST(MixedDimensions, GroupWarnsTwice) {
-    EXPECT_EQ(dimWarnings("union() { square(4); cube(1); }"),
-              (std::vector<std::string>{"WARNING: Ignoring 3D child object for 2D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
-    EXPECT_EQ(dimWarnings("union() { cube(1); square(4); }"),
-              (std::vector<std::string>{"WARNING: Ignoring 2D child object for 3D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
+TEST(MixedDimensions, KeepingBothIsSilent) {
+    // The reference warns for none of these -- verified by running it.
+    EXPECT_TRUE(dimWarnings("union() { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("union() { cube(1); square(4); }").empty());
+    EXPECT_TRUE(dimWarnings("translate([0,0,0]) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("scale(2) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("color(\"red\") { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("for (i = [0:0]) { square(4); cube(1); }").empty());
+    EXPECT_TRUE(dimWarnings("if (true) { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TransformsAndControlFlowAreGroupsToo) {
+TEST(MixedDimensions, CombiningOperationsStillPickOne) {
+    // These collapse to a single result, so a mix has no meaning and the
+    // odd child is still dropped, with both warnings.
     const std::vector<std::string> expected{"WARNING: Ignoring 3D child object for 2D operation",
                                             "WARNING: Mixing 2D and 3D objects is not supported"};
-    EXPECT_EQ(dimWarnings("translate([0,0,0]) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("scale(2) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("color(\"red\") { square(4); cube(1); }"), expected);
-    // for/if are transparent -- their children land at the top level, so
-    // they get the top level's keep-both treatment rather than a group's.
-    const std::vector<std::string> topLevel{"WARNING: Mixing 2D and 3D objects is not supported"};
-    EXPECT_EQ(dimWarnings("for (i = [0:0]) { square(4); cube(1); }"), topLevel);
-    EXPECT_EQ(dimWarnings("if (true) { square(4); cube(1); }"), topLevel);
+    EXPECT_EQ(dimWarnings("difference() { square(4); cube(1); }"), expected);
+    EXPECT_EQ(dimWarnings("intersection() { square(4); cube(1); }"), expected);
     EXPECT_EQ(dimWarnings("hull() { square(4); cube(1); }"), expected);
 }
 
@@ -678,15 +690,16 @@ TEST(MixedDimensions, RoofWarnsForNeither) {
     EXPECT_TRUE(dimWarnings("roof() { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TopLevelWarnsButKeepsBothDimensions) {
-    // The top level warns like any other group, but drops NOTHING. A real
-    // group has to pick one dimension because generateCsg builds a single
-    // result from it; the top level just hands back a list, and the
-    // reference's own preview draws 2D and 3D side by side. Dropping here
+TEST(MixedDimensions, TopLevelKeepsBothDimensionsSilently) {
+    // The top level drops NOTHING, and says nothing either: the reference
+    // is silent for `square(4); cube(1);` -- verified by running it -- and
+    // it draws 2D and 3D side by side in its own preview. Dropping here
     // silently lost the whole of a BOSL2 debug overlay (debug_bezier() of a
-    // 2D bezier is entirely 2D) whenever a 3D shape shared the script.
-    EXPECT_EQ(dimWarnings("square(4); cube(1);"),
-              (std::vector<std::string>{"WARNING: Mixing 2D and 3D objects is not supported"}));
+    // 2D bezier is entirely 2D) whenever a 3D shape shared the script; the
+    // warning went when union and the transforms learned to keep both, so
+    // that a docs figure annotating a 3D part with 2D text is not reported
+    // as a mistake.
+    EXPECT_TRUE(dimWarnings("square(4); cube(1);").empty());
     Evaluated e = evalSrc("square(4); cube(1);");
     ASSERT_EQ(e.bodies.size(), 2u);
     EXPECT_TRUE(e.bodies[0].section.has_value()) << "the 2D shape survived";

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/tests/test_python_bindings.py

@@ -405,3 +405,47 @@ def main():
 
 if __name__ == "__main__":
     main()
+
+
+def test_evaluate_generate_false_skips_geometry(tmp_path):
+    """generate=False runs the script but builds no Manifold geometry.
+
+    The point of the flag is a docs/smoke check that answers "does this
+    script run?" without paying for the solids, matching what the reference
+    does for `openscad -o out.term`.
+    """
+    from openscad_cpp_evaluator import Evaluator
+
+    src = tmp_path / "m.scad"
+    src.write_text("echo(\"ran\");\ndifference() { cube(10, center=true); sphere(6.4); }\n")
+
+    echoes = []
+    ev = Evaluator(echo_fn=echoes.append)
+    bodies, _ids = ev.evaluate(str(src), {}, generate=False)
+
+    # The language ran: the echo came out.
+    assert any("ran" in e for e in echoes)
+    # The geometry did not.
+    assert list(bodies) == []
+    assert ev.csg_tree == []
+
+    # And the same file with generate left alone still produces geometry,
+    # so the flag is what made the difference, not the script.
+    echoes2 = []
+    ev2 = Evaluator(echo_fn=echoes2.append)
+    bodies2, _ids2 = ev2.evaluate(str(src), {})
+    assert any("ran" in e for e in echoes2)
+    assert len(list(bodies2)) > 0
+    assert ev2.csg_tree != []
+
+
+def test_evaluate_generate_false_still_reports_script_errors(tmp_path):
+    """Resolve-only is still a real check: a script that fails, fails."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError
+
+    src = tmp_path / "bad.scad"
+    src.write_text("assert(false, \"nope\");\ncube(1);\n")
+
+    with pytest.raises(EvalError):
+        Evaluator(echo_fn=lambda _m: None).evaluate(str(src), {}, generate=False)

{openscad_cpp_evaluator-1.0.1 → openscad_cpp_evaluator-1.2.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.0.1"
+version = "1.2.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },