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

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

@@ -231,6 +231,15 @@ top-level 2D primitive/projection() script had been silently unexportable via th
 Fixed by porting `toRenderableBodies()` (`colored_body.hpp`/`.cpp`) and calling it from the CLI right
 before export, matching the reference's own call site exactly.
 
+`ColoredBody::sectionZ` rides alongside for the same reason. A `manifold::CrossSection` is purely
+2D, so `down(1) square(10)` had nowhere to put the `-1` and silently dropped it — and that is not
+cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's `contour()` Example 1 puts a
+blue backdrop below a green contour), and with the offset lost the two slabs became exactly
+coplanar, z-fought, and whichever drew last covered the other completely. `generateTransform`
+accumulates the z of any `translate` applied to a section, and `toRenderableBodies()` translates the
+extruded slab by it. Only translation is carried — a 2D shape under a 3D *rotation* still loses it,
+which would need a full matrix per section and nothing has asked for that yet.
+
 **Font support**: a `FontProvider` abstract interface (`font_provider.hpp`: `resolveFont`/
 `metrics`/`shapeText`/`glyphInkBounds`/`glyphOutline`) with `FreetypeFontProvider` as the built-in
 implementation everything here actually uses. `Evaluator`'s constructor takes an optional

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

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

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -68,6 +68,9 @@ struct PendingCsgWrap {
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
     std::vector<Value> groupSizes;
+    // Parallel to groupSizes: whether a group that came out EMPTY is still
+    // an operand. See Op::CsgGroupEnd's `a`.
+    std::vector<Value> emptyIsAGroup;
     size_t groupStartSize = 0;
 };
 

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -24,6 +24,21 @@ struct ColoredBody {
     std::optional<std::array<float, 4>> color; // RGBA; nullopt = "no explicit color() -- follow the live theme"
     std::optional<manifold::CrossSection> section;
     bool flatPreview = false;
+
+    // Where a 2D `section` sits along Z. Only meaningful while `section` is
+    // set, and applied when toRenderableBodies() extrudes it.
+    //
+    // A manifold::CrossSection is purely 2D, so `down(1) square(10)` had
+    // nowhere to put the -1 and silently dropped it. That is not merely
+    // cosmetic: BOSL2 layers 2D overlays by pushing one down (isosurface's
+    // contour() Example 1 puts a blue backdrop below a green contour), and
+    // with the offset lost the two slabs became exactly coplanar, z-fought,
+    // and whichever was drawn last covered the other completely.
+    //
+    // Only translation is carried. A 2D shape under a 3D ROTATION still
+    // loses it -- representing that needs a full matrix per section, which
+    // nothing has asked for yet.
+    double sectionZ = 0.0;
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
 
@@ -60,7 +75,7 @@ Value colorToValue(const std::optional<std::array<double, 4>>& color);
 std::optional<std::array<float, 4>> valueToColor(const Value& v);
 
 // Converts every top-level 2D-only result (`body` unset, `section` set --
-// e.g. a bare `circle();`) into a thin-extruded (1e-3 units tall) Manifold
+// e.g. a bare `circle();`) into a 1-unit-tall extruded Manifold
 // tagged `flatPreview = true`, so a mesh exporter/renderer that only
 // understands 3D Manifolds (writeStl/writeObj/writeOff/writeThreeMf) can
 // still show a 2D top-level result instead of silently dropping it. 3D

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

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

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

@@ -213,7 +213,8 @@ def _summarize_param(value, max_items: int = 6, max_len: int = 40) -> str:
 # Params keys never shown in format_csg_tree's per-node summary, regardless
 # of kind -- pure internal bookkeeping or already represented structurally
 # elsewhere in the tree. Mirrors the reference's _DUMP_HIDDEN_PARAM_KEYS.
-_DUMP_HIDDEN_PARAM_KEYS = frozenset({"color", "op", "name", "group_sizes"})
+_DUMP_HIDDEN_PARAM_KEYS = frozenset(
+    {"color", "op", "name", "group_sizes", "empty_is_a_group"})
 
 # Auto-generated tessellation data (not user-authored) for every kind except
 # polyhedron, where the equivalent data *is* the user's own points/faces.

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/src/builtins/booleans.cpp

@@ -108,16 +108,43 @@ CSGParams resolveCsg(Evaluator& ev, const oscad::ModularCall& node, EvalContext&
     if (!assignNodes.empty()) ev.evalChildren(assignNodes, blockCtx);
 
     std::vector<Value> groupSizes;
+    std::vector<Value> emptyIsAGroup;
     groupSizes.reserve(geoNodes.size());
+    emptyIsAGroup.reserve(geoNodes.size());
     for (const oscad::ASTNode* geoNode : geoNodes) {
         const size_t before = ev.currentTreeFrameSize();
         ev.evalChildren(std::vector<const oscad::ASTNode*>{geoNode}, blockCtx);
         groupSizes.push_back(Value{static_cast<double>(ev.currentTreeFrameSize() - before)});
+        // Whether a statement that produced NOTHING still counts as an
+        // operand.
+        //
+        // The reference builds a node for a module instantiation and for a
+        // loop whatever they contain, so an empty one is an empty operand
+        // and annihilates an intersection. An `if` that takes no branch, a
+        // bare block, and a `*`-disabled statement build no node at all, so
+        // they are not operands and must be skipped.
+        //
+        // Every line of this was checked against OpenSCAD rather than
+        // reasoned about -- `intersection(){ cube(10); X; }` keeps the cube
+        // for `if(false) sphere(6)`, `{ }` and `*cube(1)`, and comes out
+        // empty for `for(i=[1:0]) sphere(6)`, `union(){}`, `group(){}` and
+        // a call to an empty user module.
+        const oscad::NodeKind k = geoNode->kind();
+        emptyIsAGroup.push_back(Value{
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground});
     }
 
     CSGParams params;
     params["op"] = Value{op};
     params["group_sizes"] = Value{std::make_shared<const ValueList>(ValueList{std::move(groupSizes)})};
+    params["empty_is_a_group"] =
+        Value{std::make_shared<const ValueList>(ValueList{std::move(emptyIsAGroup)})};
     return params;
 }
 
@@ -180,16 +207,36 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
                                       const oscad::ASTNode&) {
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
+    const auto emptyIsAGroupIt = params.find("empty_is_a_group");
+    const std::vector<Value>* emptyIsAGroup =
+        emptyIsAGroupIt == params.end()
+            ? nullptr
+            : &std::get<ListPtr>(emptyIsAGroupIt->second)->items;
 
     std::vector<ColoredBody> allBg, allHi, allSo, allDo;
     std::optional<ColoredBody> csgResult;
     size_t idx = 0;
 
+    size_t stmtIndex = 0;
     for (const Value& sizeVal : groupSizes) {
         const size_t size = static_cast<size_t>(std::get<double>(sizeVal));
+        const size_t thisStmt = stmtIndex++;
         std::vector<ColoredBody> stmtBodies = flattenCsgTree(children, idx, size);
         idx += size;
 
+        // A statement that built no CSG node at all is not an operand --
+        // an `if` whose branch was not taken, or an empty block. Only a
+        // for-loop still counts as one when it produced nothing, matching
+        // the group node the reference builds for it regardless. Without
+        // this, `intersection(){ X; if (crop) Y; }` -- BOSL2's hirth()
+        // among others -- came out empty whenever the condition was false.
+        if (size == 0) {
+            const bool isGroup = emptyIsAGroup && thisStmt < emptyIsAGroup->size() &&
+                                  std::holds_alternative<bool>((*emptyIsAGroup)[thisStmt]) &&
+                                  std::get<bool>((*emptyIsAGroup)[thisStmt]);
+            if (!isGroup) continue;
+        }
+
         RoleSplit split = splitByRole(stmtBodies);
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/src/builtins/transforms.cpp

@@ -233,6 +233,10 @@ std::vector<ColoredBody> generateTransform(Evaluator&, const CSGParams& params,
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         if (b.section) {
+            // The CrossSection takes x/y; z has nowhere to go in it, so it
+            // rides along on the body until the section is extruded. See
+            // ColoredBody::sectionZ.
+            if (name == "translate") b.sectionZ += toVec3(getArg(args, 0, "v", Value{})).z;
             b.section = applyTransform2d(name, args, std::move(*b.section));
         } else if (b.body) {
             b.body = applyTransform3d(name, args, std::move(*b.body));

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/src/bytecode_compiler.cpp

@@ -1348,7 +1348,21 @@ public:
             }
             out.push_back({Op::CsgGroupStart, 0, 0, nullptr});
             compileStatementList(std::vector<const oscad::ASTNode*>{geoNode}, out);
-            out.push_back({Op::CsgGroupEnd, 0, 0, nullptr});
+            // `a` = whether a group that turns out EMPTY is still an
+            // operand: a module instantiation or a loop builds a node
+            // whatever it contains, an `if`/block/`*` does not. Mirrors
+            // resolveCsg's own "empty_is_a_group" (booleans.cpp), where the
+            // full reasoning and the OpenSCAD checks live.
+            const oscad::NodeKind k = geoNode->kind();
+            const int emptyIsAGroup = (
+                                       k == oscad::NodeKind::ModularCall ||
+                                       k == oscad::NodeKind::ModularFor ||
+                                       k == oscad::NodeKind::ModularIntersectionFor ||
+                                       k == oscad::NodeKind::ModularLet ||
+                                       k == oscad::NodeKind::ModularModifierShowOnly ||
+                                       k == oscad::NodeKind::ModularModifierHighlight ||
+                                       k == oscad::NodeKind::ModularModifierBackground) ? 1 : 0;
+            out.push_back({Op::CsgGroupEnd, emptyIsAGroup, 0, nullptr});
         }
         out.push_back({Op::CloseExprScope, 0, 0, nullptr});
         out.push_back({Op::PopCsgWrap, idx, 0, &call.position()});

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/src/bytecode_vm.cpp

@@ -1311,7 +1311,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     // ITERATION child ctxs are pushed separately, by the
                     // compiled loop's own Op::ForIterNext.
                     ev.treeStack_.emplace_back();
-                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, 0});
+                    f.csgWrapStack.push_back({site.op, randsBefore, ins.a, {}, {}, 0});
                     ++f.pc;
                     break;
                 }
@@ -1336,6 +1336,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                         ev.evalChildren(std::vector<const oscad::ASTNode*>{stmt}, ctx);
                         pending.groupSizes.push_back(
                             Value{static_cast<double>(ev.treeStack_.back().size() - before)});
+                        // A spliced child is a plain statement, never a loop.
+                        pending.emptyIsAGroup.push_back(Value{false});
                     }
                     ++f.pc;
                     break;
@@ -1344,6 +1346,7 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     PendingCsgWrap& pending = f.csgWrapStack.back();
                     const size_t after = ev.treeStack_.back().size();
                     pending.groupSizes.push_back(Value{static_cast<double>(after - pending.groupStartSize)});
+                    pending.emptyIsAGroup.push_back(Value{ins.a != 0});
                     ++f.pc;
                     break;
                 }
@@ -1367,6 +1370,8 @@ Value driveVm(Evaluator& ev, size_t floor) {
                     if (site.includeOpParam) params["op"] = Value{pending.op};
                     params["group_sizes"] =
                         Value{std::make_shared<const ValueList>(ValueList{std::move(pending.groupSizes)})};
+                    params["empty_is_a_group"] = Value{std::make_shared<const ValueList>(
+                        ValueList{std::move(pending.emptyIsAGroup)})};
                     // Mirrors Evaluator::buildTreeNode's own post-
                     // resolveBody() half exactly (csg_resolve.cpp).
                     const bool uncacheable =

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/src/colored_body.cpp

@@ -21,7 +21,13 @@ std::optional<std::array<float, 4>> valueToColor(const Value& v) {
 }
 
 namespace {
-constexpr double kTopLevel2dHeight = 1e-3;
+// The reference extrudes a 2D shape to exactly 1 unit for preview -- measured
+// against OpenSCAD at three camera tilts (60/70/80 degrees), which put it at
+// 0.92/1.00/0.99, the 60 being pixel-rounding on the shallowest angle. Ours
+// was 1e-3, which reads as a flat silhouette with no visible edge and, more
+// annoyingly, gives --viewall a different bounding box to fit, so every 2D
+// docs image came out at a different scale from the published one.
+constexpr double kTopLevel2dHeight = 1.0;
 } // namespace
 
 std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodies) {
@@ -31,6 +37,10 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
         if (!cb.body && cb.section) {
             ColoredBody flat;
             flat.body = manifold::Manifold::Extrude(cb.section->ToPolygons(), kTopLevel2dHeight);
+            // Put it back where a 3D translate moved it -- the CrossSection
+            // could not hold that. See ColoredBody::sectionZ.
+            if (cb.sectionZ != 0.0)
+                flat.body = flat.body->Translate(manifold::vec3(0, 0, cb.sectionZ));
             flat.color = cb.color;
             flat.flatPreview = true;
             flat.role = cb.role;

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

@@ -432,7 +432,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
     // 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
+    // not smuggle a 1-unit-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.

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

@@ -40,11 +40,76 @@ TEST(Intersection, KeepsOnlyOverlappingVolume) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 1.0, 1e-6);
 }
 
-TEST(Intersection, DisabledStatementIsTrulyEmptyAndDiscardsResult) {
+TEST(Intersection, ADisabledStatementIsNotAnOperandAtAll) {
+    // `*cube(1)` produces no CSGNode, so it is not an operand -- the
+    // intersection has one child and returns it. This used to assert an
+    // EMPTY result on the reasoning that a statement contributing no bodies
+    // is "intersection with nothing"; checking against OpenSCAD showed that
+    // is wrong (it gives volume 8, the cube(2)), and the same mistake is
+    // what made BOSL2's hirth() render nothing at all: its geometry is
+    // `intersection(){ ...; if (crop) tube(...); }` and crop defaults false.
     Evaluated e = evalSrc("intersection() { cube(2); *cube(1); }");
-    // *cube(1) produces no CSGNode at all -> its "statement" contributes a
-    // group of size 0 -- flattening an empty group yields no bodies, which
-    // intersection() treats as "intersection with nothing" -> empty result.
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
+}
+
+TEST(Intersection, AnUntakenIfIsNotAnOperandEither) {
+    // The reported case, reduced. Verified against OpenSCAD: volume 1000.
+    Evaluated e = evalSrc("intersection() { cube(10); if (false) sphere(6); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(Intersection, EmptyStatementsFollowTheReferenceExactly) {
+    // Every row checked against OpenSCAD, not reasoned about. The rule that
+    // falls out: a module instantiation or a loop builds a node whatever it
+    // contains, so an empty one is an empty operand and annihilates; an
+    // `if` with no branch taken, a bare block and a `*`-disabled statement
+    // build no node at all and are not operands.
+    struct Case { const char* stmt; bool keepsTheCube; };
+    const Case cases[] = {
+        {"if (false) sphere(6);",            true},
+        {"{ }",                              true},
+        {"*cube(1);",                        true},
+        {"for (i = [1:0]) sphere(6);",       false},
+        {"union() { }",                      false},
+        {"group() { }",                      false},
+        {"let(x = 1) { }",                   false},
+        {"#union() { }",                     false},
+    };
+    for (const Case& c : cases) {
+        const std::string src =
+            std::string("intersection() { cube(10, center=true); ") + c.stmt + " }";
+        Evaluated e = evalSrc(src);
+        if (c.keepsTheCube) {
+            ASSERT_EQ(e.bodies.size(), 1u) << src;
+            EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6) << src;
+        } else {
+            const bool anyVolume = std::any_of(
+                e.bodies.begin(), e.bodies.end(),
+                [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+            EXPECT_FALSE(anyVolume) << src;
+        }
+    }
+}
+
+TEST(Intersection, AnEmptyUserModuleIsStillAnOperand) {
+    // The reference builds a node for a module instantiation whatever the
+    // module's body does, so calling one that draws nothing empties the
+    // intersection. Verified against OpenSCAD (writes no STL).
+    Evaluated e = evalSrc("module m() { } intersection() { cube(10); m(); }");
+    const bool anyVolume = std::any_of(
+        e.bodies.begin(), e.bodies.end(),
+        [](const ColoredBody& b) { return b.body && !b.body->IsEmpty(); });
+    EXPECT_FALSE(anyVolume);
+}
+
+TEST(Intersection, AnEmptyForLoopIsStillAnOperand) {
+    // The one empty statement that DOES annihilate: the reference builds a
+    // group node for a for-loop however many times it iterates, so an empty
+    // one is an empty operand. Verified against OpenSCAD, which writes no
+    // STL at all for this.
+    Evaluated e = evalSrc("intersection() { cube(10); for (i = [1:0]) sphere(6); }");
     EXPECT_TRUE(e.bodies.empty());
 }
 
@@ -73,14 +138,19 @@ TEST(Union, MultipleBodiesInFirstStatementAllSurvive) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 20.0, 1e-6);
 }
 
-TEST(Intersection, EmptyFirstOperandGivesEmpty) {
+TEST(Intersection, ADisabledFirstStatementLetsTheNextOneLead) {
+    // Verified against OpenSCAD: volume 8, not empty.
     Evaluated e = evalSrc("intersection() { *cube(10); cube(2); }");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
-TEST(Difference, EmptyFirstOperandGivesEmpty) {
+TEST(Difference, ADisabledFirstStatementLetsTheNextOneBecomeTheBase) {
+    // Verified against OpenSCAD: volume 8 -- cube(2) becomes the base
+    // rather than the difference collapsing to nothing.
     Evaluated e = evalSrc("difference() { *cube(10); cube(2); }");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
 TEST(Difference, EmptySubtractorLeavesBaseUnchanged) {
@@ -625,7 +695,7 @@ TEST(MixedDimensions, TopLevelWarnsButKeepsBothDimensions) {
 
 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
+    // toRenderableBodies. A mesh export must not smuggle that 1-unit-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);
@@ -633,7 +703,7 @@ TEST(MixedDimensions, ExportDropsTheFlatSlabWhenRealSolidsArePresent) {
 
     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.
+    // Only the cube survives, so the height is the cube's own.
     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]);
@@ -651,6 +721,44 @@ TEST(MixedDimensions, ExportKeepsTheFlatSlabWhenItIsTheOnlyGeometry) {
     EXPECT_EQ(objects.size(), 1u);
 }
 
+TEST(MixedDimensions, ATranslatedTwoDeeShapeKeepsItsZ) {
+    // A CrossSection is purely 2D, so `translate([0,0,-1]) square(10)` had
+    // nowhere to put the -1 and dropped it. Two 2D shapes meant to be
+    // layered then came out exactly coplanar, z-fought, and whichever drew
+    // last hid the other -- BOSL2's isosurface contour() Example 1 renders a
+    // green contour over a blue backdrop pushed down by 1, and the backdrop
+    // covered the contour completely.
+    Evaluated e = evalSrc("translate([0,0,-1]) square(10, center=true);");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    EXPECT_DOUBLE_EQ(e.bodies[0].sectionZ, -1.0);
+
+    const std::vector<ColoredBody> renderable = toRenderableBodies(e.bodies);
+    ASSERT_EQ(renderable.size(), 1u);
+    ASSERT_TRUE(renderable[0].body.has_value());
+    const manifold::Box box = renderable[0].body->BoundingBox();
+    EXPECT_NEAR(box.min.z, -1.0, 1e-9) << "the extruded slab sits where it was moved to";
+}
+
+TEST(MixedDimensions, TwoDeeZOffsetsAccumulateAndDefaultToZero) {
+    Evaluated flat = evalSrc("square(10);");
+    ASSERT_EQ(flat.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(flat.bodies[0].sectionZ, 0.0);
+
+    Evaluated stacked = evalSrc(
+        "translate([0,0,2]) translate([0,0,3]) square(10);");
+    ASSERT_EQ(stacked.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(stacked.bodies[0].sectionZ, 5.0);
+
+    // x/y still go into the CrossSection itself, not the offset.
+    Evaluated moved = evalSrc("translate([4,5,6]) square(10);");
+    ASSERT_EQ(moved.bodies.size(), 1u);
+    EXPECT_DOUBLE_EQ(moved.bodies[0].sectionZ, 6.0);
+    const manifold::Rect r = moved.bodies[0].section->Bounds();
+    EXPECT_NEAR(r.min.x, 4.0, 1e-9);
+    EXPECT_NEAR(r.min.y, 5.0, 1e-9);
+}
+
 TEST(MixedDimensions, UniformChildrenAreUntouched) {
     EXPECT_TRUE(dimWarnings("union() { cube(1); cube(2); }").empty());
     EXPECT_TRUE(dimWarnings("union() { square(1); square(2); }").empty());

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/tests/test_control_flow.cpp

@@ -845,15 +845,15 @@ TEST(ExprEvalFunctionCall, CallingANonFunctionVariableWarnsAndIsUndef) {
     EXPECT_NE(warnings.back().find("Ignoring unknown function 'x'"), std::string::npos);
 }
 
-TEST(Intersection, EchoInDisabledFirstStatementStillFiresDespiteEmptyResult) {
-    // A deliberate resolve/generate-split consequence: resolve can't yet
-    // know the whole intersection() will end up geometrically empty (that
-    // isn't known until generate time), so echo()'s side effect during
-    // resolve still fires even though the final result has zero bodies.
+TEST(Intersection, EchoInADisabledStatementStillFires) {
+    // echo() runs during resolve, so its side effect happens whatever the
+    // geometry does. The result is the cube(2): neither the disabled
+    // statement nor the echo statement is an operand.
     std::string captured;
     Evaluated e = evalSrc("intersection() { *cube(10); echo(\"fired\"); cube(2); }", [&](const std::string& msg) { captured = msg; });
     EXPECT_EQ(captured, "ECHO: \"fired\"");
-    EXPECT_TRUE(e.bodies.empty());
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6);
 }
 
 TEST(ListComprehension, IfClauseWithNestedListLiteralBody) {

{openscad_cpp_evaluator-0.55.2 → openscad_cpp_evaluator-0.55.4}/tests/test_export.cpp

@@ -91,7 +91,7 @@ TEST(ExportStl, NoGeometryThrows) {
 TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     // A bare `circle();` (no `body`, only `section`) would make writeStl
     // throw "No geometry to export" -- toRenderableBodies() converts it
-    // into a thin (1e-3 unit tall) Manifold first, mirroring the reference
+    // into a 1-unit-tall Manifold first, mirroring the reference
     // CLI's own to_renderable_bodies() call right before export. Without
     // this step, no top-level 2D-only script could ever export a mesh.
     std::vector<ColoredBody> bodies = evalToBodies("circle(2, $fn=32);");
@@ -104,7 +104,9 @@ TEST(ToRenderableBodies, ThinExtrudesABareTopLevel2dShapeSoItCanExportAsStl) {
     ASSERT_TRUE(renderable[0].body.has_value());
     EXPECT_TRUE(renderable[0].flatPreview);
     manifold::Box bbox = renderable[0].body->BoundingBox();
-    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1e-3, 1e-9);
+    // 1 unit, matching what the reference extrudes a 2D preview to --
+    // measured against OpenSCAD at three camera tilts.
+    EXPECT_NEAR(bbox.max.z - bbox.min.z, 1.0, 1e-9);
 
     const std::string path = tempPath("flat_preview.stl").string();
     writeStl(path, renderable);