openscad-cpp-evaluator 0.55.0__tar.gz → 0.55.2__tar.gz

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/CLAUDE.md

@@ -699,6 +699,17 @@ grep for `ponytail:`.
   permanent cache miss for any subtree that called `rands()` while resolving, since such a
   subtree's resolved params aren't a pure function of its own content anymore (the actual `rands()`
   output also depends on every earlier `rands()` call's position in the whole evaluation's order).
+  A second, separate taint — `CSGNode::keyHasClosure`, set by `cacheKey()` itself rather than at
+  resolve time — does the same for any subtree holding a **function literal** in its params (the
+  `levelset(function (x,y,z) ..., ...)` shape). `canonValue()` can only key a closure by its AST
+  node's raw address, which is meaningful for exactly one parse: the next render frees that AST and
+  a fresh closure over *different* captured values can be allocated at the very same address, so
+  the key silently hits the previous render's geometry — the GUI symptom was an edited script
+  rendering its **old** shape until saved a second time. (The address also ignores the captured
+  values themselves, so two closures over one literal collide within a single render, which is what
+  `tests/test_manifold_cache.cpp` pins down deterministically.) Keying a closure honestly means
+  canonicalizing its captured `let_` trail, which is type-erased (`Closure::capturedLet` is a
+  `shared_ptr<void>`); until that exists such a subtree simply does not participate in the cache.
   Builtins are registered in `src/builtins/registry.cpp` as `(name string) -> (ResolveFn,
   GenerateFn)` pairs — `dispatch.hpp` has the exact reasoning for `GenerateFn`'s `Evaluator&`
   parameter (provenance-table writes only, no `EvalContext`/dynamic-scope access, so the

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/PKG-INFO

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

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/bindings/ast_to_py.cpp

@@ -25,6 +25,7 @@
 // losing how the author wrote it (1.500 -> 1.5, 1e3 -> 1000).
 
 #include "openscad_cpp_parser/api.hpp"
+#include "openscad_cpp_parser/pretty_print.hpp"
 #include "openscad_cpp_parser/ast/ast_node.hpp"
 #include "openscad_cpp_parser/ast/comments.hpp"
 #include "openscad_cpp_parser/ast/declarations.hpp"
@@ -323,4 +324,11 @@ nb::list parseAstFromString(const std::string& code, bool includeComments) {
     return astToPy(oscad::getASTFromString(code, includeComments));
 }
 
+// The parser already has a pretty-printer -- comment-preserving, idempotent
+// and covered by its own tests -- so an editor's "reformat" needs no second
+// implementation guessing at the same grammar from a token stream.
+std::string formatSourceString(const std::string& code, int indentWidth, bool includeComments) {
+    return oscad::toOpenscad(oscad::getASTFromString(code, includeComments), indentWidth);
+}
+
 } // namespace oscadbind

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/bindings/module.cpp

@@ -49,6 +49,7 @@ namespace nb = nanobind;
 namespace oscadbind {
 nb::list parseAstFromFile(const std::string& path, bool includeComments);
 nb::list parseAstFromString(const std::string& code, bool includeComments);
+std::string formatSourceString(const std::string& code, int indentWidth, bool includeComments);
 } // namespace oscadbind
 
 namespace {
@@ -809,6 +810,13 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "safe to keep, share across threads, and outlive the parse.");
     m.def("parse_ast_string", &oscadbind::parseAstFromString, nb::arg("code"), nb::arg("include_comments") = false,
           "As parse_ast(), but parses a source string instead of a file.");
+    m.def("format_source", &oscadbind::formatSourceString, nb::arg("code"),
+          nb::arg("indent") = 4, nb::arg("include_comments") = true,
+          "Reformat OpenSCAD source: parse it and print the AST back out. "
+          "Wraps over-long argument lists and vectors, puts a modifier's "
+          "children on their own indented line, and preserves comments. "
+          "Idempotent -- formatting formatted source returns it unchanged. "
+          "Raises ParseError if the source does not parse.");
     m.def("debug_evaluate", &debugEvaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("debug_hook"),
           nb::arg("error_break"), nb::arg("echo_fn"), nb::arg("manifold_cache") = nullptr,
           nb::arg("return_hook") = nb::none(), nb::arg("fast_continue_signal") = nullptr,

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -72,6 +72,21 @@ struct CSGNode {
     // on first cacheKey() call; every node here is always reached through a
     // non-const CSGNode&, so no `mutable` is needed to write it.
     std::optional<std::string> cachedKey;
+
+    // Set by the same cacheKey() pass that fills cachedKey: true if this
+    // node's own params, or any descendant's, hold a function literal.
+    //
+    // canonValue() can only key a closure by its AST node's raw address,
+    // and that address is meaningful for exactly one parse: the next
+    // render frees that AST, and a fresh closure over different captured
+    // values can be allocated at the very same address -- so the key
+    // silently hits the PREVIOUS render's geometry. (It also ignores the
+    // captured values themselves, so two closures over one literal share a
+    // key within a single render.) Keying a closure honestly would mean
+    // canonicalising its captured `let_` trail, which is type-erased; until
+    // that exists, such a subtree just does not participate in the cache.
+    // See csg_generate.cpp's lookup.
+    bool keyHasClosure = false;
 };
 
 

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -427,7 +427,8 @@ public:
     // before its GenerateFn runs -- see csg_generate.cpp.
     void applyDimensionRules(CSGNode& node);
     // ruleValue is a DimRule; the enum is file-local to csg_generate.cpp.
-    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue);
+    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue,
+                                bool keepMixed = false);
 
     // Apply `!`: replace the whole tree with the first show_only
     // subtree, discarding its ancestors and every sibling. See its

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/pyproject.toml

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

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/python/openscad_cpp_evaluator/__init__.py

@@ -18,7 +18,8 @@ from ._openscad_cpp_evaluator import FastContinueSignal, ManifoldCache
 __all__ = [
     "Evaluator", "ColoredBody", "EvalError", "ParseError", "OscObject", "parse", "to_renderable_bodies",
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
-    "FastContinueSignal", "parse_ast", "parse_ast_string", "check_mesh", "strip_slivers",
+    "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
+    "check_mesh", "strip_slivers",
     "export_model", "export_extensions",
 ]
 
@@ -376,6 +377,24 @@ def parse_ast_string(code: str, include_comments: bool = False) -> list:
         raise ParseError(str(e)) from e
 
 
+def format_source(code: str, indent: int = 4, include_comments: bool = True) -> str:
+    """Reformat OpenSCAD source: parse it and print the AST back out.
+
+    Wraps over-long argument lists and vector literals, puts a modifier's
+    children on their own indented line, and preserves comments. Idempotent
+    -- formatting already-formatted source returns it unchanged. Raises
+    ParseError on a syntax error.
+
+    This is the parser's own printer (`oscad::toOpenscad`), so an editor
+    reformatting a selection does not need a second implementation guessing
+    at the same grammar from a token stream.
+    """
+    try:
+        return _ext.format_source(code, indent, include_comments)
+    except Exception as e:
+        raise ParseError(str(e)) from e
+
+
 class _MeshShim:
     """Duck-types a manifold3d mesh: the four arrays the renderer reads."""
     __slots__ = ("vert_properties", "tri_verts", "run_original_id", "run_index", "num_prop")

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/src/csg_generate.cpp

@@ -44,7 +44,15 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
         // re-deriving results that would just be discarded. Mirrors
         // generate_tree()'s own cache check exactly.
         std::optional<std::string> key;
-        if (manifoldCache_ && !node.uncacheable) key = cacheKey(node);
+        if (manifoldCache_ && !node.uncacheable) {
+            key = cacheKey(node);
+            // A key that serialized a function literal is not a pure
+            // function of content -- it embeds a raw AST address that the
+            // next parse can hand out again. Dropping the key here forces
+            // both the get() below and the put() further down to be
+            // skipped. See CSGNode::keyHasClosure.
+            if (node.keyHasClosure) key.reset();
+        }
         std::optional<std::vector<ColoredBody>> cached = key ? manifoldCache_->get(*key) : std::nullopt;
         if (cached) {
             node.bodies = std::move(*cached);
@@ -163,9 +171,10 @@ void Evaluator::applyDimensionRules(CSGNode& node) {
     applyDimensionRulesTo(kids, static_cast<int>(rule));
 }
 
-// The top level is an implicit union, and the reference treats it as one for
-// this too: `square(4); cube(1);` warns and keeps only the square.
-void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue) {
+// `keepMixed` warns about a mixed group but drops nothing -- the top level's
+// behaviour, see generateTree.
+void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue,
+                                       bool keepMixed) {
     const DimRule rule = static_cast<DimRule>(ruleValue);
     int target = rule == DimRule::Only2D ? 2 : rule == DimRule::Only3D ? 3 : 0;
     bool warnedMixing = false;
@@ -194,6 +203,16 @@ void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int
                 warn("Mixing 2D and 3D objects is not supported", pos);
                 warnedMixing = true;
             }
+            if (keepMixed) {
+                // Kept, not dropped: at the top level there is no single
+                // result to build, so nothing downstream can be confused by
+                // the other dimension, and the reference's own preview shows
+                // both. The warning above still stands -- an export cannot
+                // represent the mix -- but silently losing the 2D geometry
+                // from the picture is worse than showing it.
+                kept.push_back(std::move(b));
+                continue;
+            }
             warn(std::string("Ignoring ") + (dim == 3 ? "3D" : "2D") + " child object for " +
                      (target == 3 ? "3D" : "2D") + " operation",
                  pos);
@@ -208,9 +227,19 @@ std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_p
     ptrs.reserve(tree.size());
     for (const std::unique_ptr<CSGNode>& n : tree) ptrs.push_back(n.get());
     std::vector<ColoredBody> bodies = generateTreeImpl(ptrs);
-    // The top level is an implicit union; give it the same Group treatment
-    // every other group node gets, then re-collect what survived.
-    applyDimensionRulesTo(ptrs, static_cast<int>(DimRule::Group));
+    // The top level is an implicit union, so it gets the same Group warning
+    // every other group node gets -- but it KEEPS both dimensions.
+    //
+    // A real group has to pick one: generateCsg builds a single result and
+    // switches on whether it holds a body or a section, so a group that
+    // changed dimension part-way used to take the process down. The top
+    // level builds no such result; it just hands back a list. Dropping there
+    // only lost geometry, and it lost it from the picture: the reference's
+    // preview draws top-level 2D and 3D side by side (a 2D shape as a thin
+    // slab), which is exactly what BOSL2's debug_bezier() of a 2D bezier
+    // relies on -- every curve and control arrow it draws is 2D, so beside
+    // a 3D sphere the whole debug overlay vanished.
+    applyDimensionRulesTo(ptrs, static_cast<int>(DimRule::Group), /*keepMixed=*/true);
     bodies.clear();
     for (CSGNode* n : ptrs) {
         for (const ColoredBody& b : n->bodies) bodies.push_back(b);

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/src/export.cpp

@@ -429,10 +429,23 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
     std::vector<Solid> solids;
     std::vector<ExportObject> loose;
 
+    // A `flatPreview` body is a top-level 2D shape thin-extruded so it can be
+    // SEEN (toRenderableBodies). The top level keeps 2D and 3D side by side
+    // for exactly that reason -- but a mesh export of a mixed script must
+    // not smuggle a 1e-3-tall slab in beside the real solids, which is what
+    // the reference drops there too. A 2D-ONLY script still exports its
+    // slab, unchanged: that is the only geometry there is, and dropping it
+    // would leave nothing to write.
+    bool hasRealSolid = false;
+    for (const ColoredBody& cb : bodies) {
+        if (!cb.flatPreview && isExportable(cb)) { hasRealSolid = true; break; }
+    }
+
     int index = 0;
     for (const ColoredBody& cb : bodies) {
         ++index;
         if (!isExportable(cb)) continue;
+        if (cb.flatPreview && hasRealSolid) continue;
         if (cb.isDisplayOnly()) {
             // Manifold rejected this one -- an open shell is not a solid --
             // so it can join no boolean. Its triangles are real geometry the

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/src/manifold_cache.cpp

@@ -93,6 +93,32 @@ std::string canonValue(const Value& v) {
         v);
 }
 
+// True if `v` is a function literal, or a list/object holding one at any
+// depth. Drives CSGNode::keyHasClosure -- see its doc comment for why a
+// closure cannot be keyed.
+bool valueHasClosure(const Value& v) {
+    return std::visit(
+        [](const auto& val) -> bool {
+            using T = std::decay_t<decltype(val)>;
+            if constexpr (std::is_same_v<T, ClosurePtr>) {
+                return true;
+            } else if constexpr (std::is_same_v<T, ListPtr>) {
+                if (!val) return false;
+                for (const Value& item : val->items)
+                    if (valueHasClosure(item)) return true;
+                return false;
+            } else if constexpr (std::is_same_v<T, ObjectPtr>) {
+                if (!val) return false;
+                for (const auto& [k, vv] : val->items)
+                    if (valueHasClosure(vv)) return true;
+                return false;
+            } else {
+                return false;
+            }
+        },
+        v);
+}
+
 std::string canonParams(const CSGParams& params) {
     std::vector<std::pair<std::string, std::string>> entries;
     entries.reserve(params.size());
@@ -120,13 +146,24 @@ std::string canonParams(const CSGParams& params) {
 std::string cacheKey(CSGNode& node) {
     if (node.cachedKey) return *node.cachedKey;
 
+    bool hasClosure = false;
+    for (const auto& [k, v] : node.params) {
+        if (valueHasClosure(v)) { hasClosure = true; break; }
+    }
+
     std::string out = "N(";
     appendLenPrefixed(out, node.kind);
     out += node.isBuiltin ? "1" : "0";
     appendLenPrefixed(out, canonParams(node.params));
     out += std::to_string(node.children.size()) + "[";
-    for (const auto& c : node.children) appendLenPrefixed(out, cacheKey(*c));
+    for (const auto& c : node.children) {
+        appendLenPrefixed(out, cacheKey(*c));
+        // A closure anywhere below poisons this key too: it is built from
+        // the children's keys.
+        hasClosure = hasClosure || c->keyHasClosure;
+    }
     out += "])";
+    node.keyHasClosure = hasClosure;
     node.cachedKey = out;
     return *node.cachedKey;
 }

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/tests/test_booleans.cpp

@@ -1,4 +1,6 @@
 #include "openscad_cpp_evaluator/evaluator.hpp"
+#include "openscad_cpp_evaluator/colored_body.hpp"
+#include "openscad_cpp_evaluator/export.hpp"
 
 #include "test_helpers.hpp"
 
@@ -576,8 +578,11 @@ TEST(MixedDimensions, TransformsAndControlFlowAreGroupsToo) {
     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);
-    EXPECT_EQ(dimWarnings("for (i = [0:0]) { square(4); cube(1); }"), expected);
-    EXPECT_EQ(dimWarnings("if (true) { 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("hull() { square(4); cube(1); }"), expected);
 }
 
@@ -603,14 +608,47 @@ TEST(MixedDimensions, RoofWarnsForNeither) {
     EXPECT_TRUE(dimWarnings("roof() { square(4); cube(1); }").empty());
 }
 
-TEST(MixedDimensions, TopLevelIsAGroupAsWell) {
-    // The top level is an implicit union, and gets the same treatment.
+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
+    // 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: Ignoring 3D child object for 2D operation",
-                                        "WARNING: Mixing 2D and 3D objects is not supported"}));
+              (std::vector<std::string>{"WARNING: Mixing 2D and 3D objects is not supported"}));
     Evaluated e = evalSrc("square(4); cube(1);");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    EXPECT_TRUE(e.bodies[0].section.has_value());
+    ASSERT_EQ(e.bodies.size(), 2u);
+    EXPECT_TRUE(e.bodies[0].section.has_value()) << "the 2D shape survived";
+    EXPECT_TRUE(e.bodies[1].body.has_value()) << "and so did the 3D one";
+}
+
+TEST(MixedDimensions, ExportDropsTheFlatSlabWhenRealSolidsArePresent) {
+    // The top level keeps a 2D shape so it can be SEEN, thin-extruded by
+    // toRenderableBodies. A mesh export must not smuggle that 1e-3-tall slab
+    // in beside the real solids -- the reference drops it there too.
+    Evaluated e = evalSrc("square(4); cube(1);");
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 2u) << "both are still drawn";
+
+    const std::vector<ExportObject> objects = splitBodiesForExport(renderable, nullptr);
+    ASSERT_EQ(objects.size(), 1u) << "but only the cube is exported";
+    // The cube is a unit tall; the dropped slab would have been 1e-3.
+    float zmin = 1e9f, zmax = -1e9f;
+    for (size_t i = 2; i < objects[0].verts.size(); i += 3) {
+        zmin = std::min(zmin, objects[0].verts[i]);
+        zmax = std::max(zmax, objects[0].verts[i]);
+    }
+    EXPECT_NEAR(zmax - zmin, 1.0f, 1e-5f);
+}
+
+TEST(MixedDimensions, ExportKeepsTheFlatSlabWhenItIsTheOnlyGeometry) {
+    // A 2D-only script has nothing else to write, so its slab still exports
+    // -- unchanged behaviour, and the only reason the filter is conditional.
+    Evaluated e = evalSrc("square(4);");
+    const std::vector<ExportObject> objects =
+        splitBodiesForExport(toRenderableBodies(e.bodies), nullptr);
+    EXPECT_EQ(objects.size(), 1u);
 }
 
 TEST(MixedDimensions, UniformChildrenAreUntouched) {

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/tests/test_manifold_cache.cpp

@@ -121,6 +121,65 @@ TEST(ManifoldCacheUncacheable, RandsBeforeGeometryInModuleBodyTaintsSplicedSibli
     EXPECT_TRUE(e.tree[0]->uncacheable);
 }
 
+// -- closure taint ---------------------------------------------------------
+
+TEST(ManifoldCacheClosure, PlainNodeHasNoClosureTaint) {
+    Evaluated e = evalSrc("cube(5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_FALSE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, FunctionLiteralParamTaintsTheNode) {
+    Evaluated e = evalSrc(
+        "levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+TEST(ManifoldCacheClosure, TaintPropagatesUpThroughATransform) {
+    // The parent's key is built from the child's, so a closure below is
+    // just as unusable there.
+    Evaluated e = evalSrc(
+        "translate([1,0,0]) levelset(function (x,y,z) x*x+y*y+z*z-100,"
+        "         bounds=[[-15,-15,-15],[15,15,15]], edge=5);");
+    ASSERT_EQ(e.tree.size(), 1u);
+    EXPECT_EQ(e.tree[0]->kind, "translate");
+    cacheKey(*e.tree[0]);
+    EXPECT_TRUE(e.tree[0]->keyHasClosure);
+}
+
+// The bug this taint exists for, at full size: both closures come from the
+// SAME function literal (so canonValue's "F<pointer>" is byte-identical)
+// but capture different `r`. Every other cache-key input matches too, so
+// before the taint the second levelset() was served the first one's
+// geometry and both spheres came out radius 10.
+//
+// Deterministic on purpose: one evaluation, one AST, so the two closures
+// genuinely share a node address rather than relying on the allocator
+// handing back a freed one.
+TEST(ManifoldCacheClosure, TwoClosuresOverOneLiteralAreNotServedEachOthersGeometry) {
+    auto cache = std::make_shared<ManifoldCache>();
+    Evaluated e = evalSrcWithCache(
+        "function mk(r) = function (x,y,z) x*x+y*y+z*z-r*r;\n"
+        "levelset(mk(10), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n"
+        "translate([40,0,0])\n"
+        "  levelset(mk(5), bounds=[[-15,-15,-15],[15,15,15]], edge=2);\n",
+        cache);
+
+    ASSERT_EQ(e.bodies.size(), 2u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    ASSERT_TRUE(e.bodies[1].body.has_value());
+    const double volBig = e.bodies[0].body->Volume();
+    const double volSmall = e.bodies[1].body->Volume();
+    // Coarse sampling, so compare the two against each other rather than
+    // against 4/3*pi*r^3: r=10 vs r=5 is an 8x volume ratio.
+    EXPECT_GT(volBig, 2.0 * volSmall)
+        << "the second closure was served the first one's cached geometry";
+}
+
 // -- cache reuse -----------------------------------------------------------
 
 TEST(ManifoldCache, CacheHitSkipsRegeneratingTheSubtree) {

{openscad_cpp_evaluator-0.55.0 → openscad_cpp_evaluator-0.55.2}/tests/test_python_bindings.py

@@ -351,6 +351,43 @@ def test_parse_ast_raises_parse_error_on_bad_syntax():
     raise AssertionError("expected ParseError")
 
 
+def test_format_source_round_trips_and_is_idempotent():
+    from openscad_cpp_evaluator import format_source
+
+    out = format_source("module thing(a=1,b=[1,2,3]){translate([0,0,1])cube([a,a,a]);}\n")
+    assert "module thing(a=1, b=[1, 2, 3])" in out, out
+    # A modifier's children go on their own indented line.
+    assert "translate([0, 0, 1])\n        cube([a, a, a]);" in out, out
+    # Formatting formatted source changes nothing: the printer is the
+    # parser's own, so its output parses back to the same tree.
+    assert format_source(out) == out
+
+
+def test_format_source_keeps_comments():
+    from openscad_cpp_evaluator import format_source
+
+    out = format_source("// keep me\ncube(1);\n")
+    assert "// keep me" in out, out
+    # ...and can be told not to.
+    assert "// keep me" not in format_source("// keep me\ncube(1);\n", include_comments=False)
+
+
+def test_format_source_honours_the_indent_width():
+    from openscad_cpp_evaluator import format_source
+
+    two = format_source("module m(){cube(1);}\n", indent=2)
+    assert "\n  cube(1);" in two, two
+
+
+def test_format_source_raises_parse_error_on_bad_input():
+    from openscad_cpp_evaluator import ParseError, format_source
+    try:
+        format_source("module {{{")
+    except ParseError:
+        return
+    raise AssertionError("expected ParseError")
+
+
 def main():
     tests = [v for k, v in sorted(globals().items()) if k.startswith("test_") and callable(v)]
     failures = []