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

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

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

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

@@ -294,6 +294,15 @@ public:
     // depth-first on one thread.
     const oscad::Position* generateWarnEntry = nullptr;
 
+    // Set while generating anything beneath a hull(). An open mesh there is
+    // not a mistake to report: a convex hull needs only points, so BOSL2's
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices in. The reference says nothing
+    // about it, and spheroid(circum=true, style="icosa") goes through that
+    // path -- warning would fire on an everyday BOSL2 call. Covers the whole
+    // subtree, not just direct children, since hull() consumes all of it.
+    bool insideHull = false;
+
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
     // tagGenerated()'s counterpart for a mesh Manifold refused to build --

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

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

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/import.cpp

@@ -318,10 +318,13 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
         const MeshDiagnosis d = checkMesh(mesh);
         std::string why = d.summary();
         if (why.empty()) why = manifoldErrorName(body.Status());
-        ev.warn("import: mesh is not a closed solid (" + why +
-                    "); drawing it as a surface, but it cannot take part in any CSG "
-                    "operation" + (repair ? "" : ". Try import(..., repair=true)"),
-                &node.position());
+        if (!ev.insideHull) {
+            ev.warn("import: mesh is not a closed solid (" + why +
+                        "); drawing it as a surface. hull() can still use its points, but "
+                        "it cannot take part in union/difference/intersection" +
+                        std::string(repair ? "" : ". Try import(..., repair=true)"),
+                    &node.position());
+        }
         // tagDisplayOnly carries a raw triangle soup for the renderer to
         // draw, and the renderer is float either way, so narrowing here
         // costs nothing this mesh will ever be measured on.

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/primitives_3d.cpp

@@ -781,6 +781,14 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
+    // No faces at all is empty geometry, not a failure. BOSL2's debug_vnf()
+    // passes [verts, []] to draw vertex labels with no surface, and real
+    // OpenSCAD accepts `polyhedron(points=..., faces=[])` silently. Checked
+    // before the status branches below, which would otherwise report the
+    // empty mesh as NotManifold and discard it with a warning.
+    if (mesh.triVerts.empty()) {
+        return {ev.tagGenerated(manifold::Manifold(), node, params.at("color"))};
+    }
     manifold::Manifold body(mesh);
     if (isDrawableFailure(body, mesh)) {
         // An open surface -- faces that don't close the solid. Manifold
@@ -794,10 +802,12 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         // closed mesh with reversed winding, non-manifold vertices or
         // self-intersections builds perfectly well, and only an OPEN one
         // reaches this branch. The count points straight at the problem.
-        ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
-                    " boundary edge(s); drawing it as a surface, but it cannot "
-                    "take part in any CSG operation",
-                &node.position());
+        if (!ev.insideHull) {
+            ev.warn("polyhedron: mesh is not closed -- " + std::to_string(countBoundaryEdges(mesh)) +
+                        " boundary edge(s); drawing it as a surface. hull() can still "
+                        "use its points, but it cannot take part in union/difference/intersection",
+                    &node.position());
+        }
         manifold::MeshGL soup;
         soup.numProp = 3;
         soup.vertProperties.assign(mesh.vertProperties.begin(), mesh.vertProperties.end());

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/src/builtins/topology.cpp

@@ -35,19 +35,51 @@ CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext
 // matching the reference's own `if bodies_3d: ... else: sections...`
 // either/or dispatch). background/highlight/show_only bodies pass through
 // untouched, same as union/difference/intersection.
+// Vertex positions out of a MeshGL, whatever else it carries per vertex.
+// Only the first three properties are the position; numProp may be larger.
+static void appendVertices(const manifold::MeshGL& mesh, std::vector<manifold::vec3>& out) {
+    const size_t stride = mesh.numProp;
+    if (stride < 3) return;
+    for (size_t i = 0; i + 2 < mesh.vertProperties.size(); i += stride)
+        out.push_back({mesh.vertProperties[i], mesh.vertProperties[i + 1],
+                       mesh.vertProperties[i + 2]});
+}
+
 std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::vector<std::unique_ptr<CSGNode>>& children,
                                        const oscad::ASTNode&) {
     const std::vector<ColoredBody> bodies = flattenCsgTree(children);
     if (bodies.empty()) return {};
     const RoleSplit split = splitByRole(bodies);
 
+    // An open mesh has no Manifold, but a convex hull only ever needed its
+    // POINTS -- closedness is irrelevant to one. BOSL2 depends on this:
+    // hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+    // face list purely to carry the vertices into hull(), and
+    // spheroid(circum=true, style="icosa") goes through it. Dropping those
+    // children left the loose triangles to fall through un-hulled, which is
+    // what the reference does not do.
+    std::vector<manifold::vec3> loosePoints;
+    for (const ColoredBody& c : split.displayOnly) {
+        if (c.rawMesh) appendVertices(*c.rawMesh, loosePoints);
+    }
+
     std::optional<ColoredBody> hullResult;
-    if (!split.foreground.empty()) {
+    if (!split.foreground.empty() || !loosePoints.empty()) {
         std::vector<manifold::Manifold> bodies3d;
         for (const ColoredBody& c : split.foreground) {
             if (c.body) bodies3d.push_back(*c.body);
         }
-        if (!bodies3d.empty()) {
+        if (!loosePoints.empty()) {
+            // Hulling points and bodies together has to go through the
+            // point overload, so the solids contribute their vertices too.
+            for (const manifold::Manifold& m : bodies3d)
+                appendVertices(m.GetMeshGL(), loosePoints);
+            ColoredBody cb;
+            cb.body = manifold::Manifold::Hull(loosePoints);
+            cb.color = split.foreground.empty() ? split.displayOnly.front().color
+                                                : split.foreground.front().color;
+            hullResult = std::move(cb);
+        } else if (!bodies3d.empty()) {
             ColoredBody cb;
             cb.body = manifold::Manifold::Hull(bodies3d);
             cb.color = split.foreground.front().color;
@@ -71,7 +103,10 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
     result.insert(result.end(), split.background.begin(), split.background.end());
     result.insert(result.end(), split.highlight.begin(), split.highlight.end());
     result.insert(result.end(), split.showOnly.begin(), split.showOnly.end());
-    result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
+    // Only pass the open meshes through if they were NOT hulled; hull()
+    // consumes its children, so re-adding them would draw them twice.
+    if (loosePoints.empty())
+        result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
     return result;
 }
 

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/src/bytecode_compiler.cpp

@@ -1564,35 +1564,31 @@ public:
                 return;
             }
             case NodeKind::ModularLet: {
-                // Mirrors Evaluator::evalLetBlock exactly (stmt_eval.cpp):
-                // every assignment's RHS is evaluated against the
-                // ORIGINAL (parent) ctx, never an earlier sibling's own
-                // write in THIS SAME let-block (a documented, deliberate
-                // divergence from the let-EXPRESSION form's sequential
-                // visibility) -- so every RHS is compiled+evaluated FIRST,
-                // all left on f.stack, and only written into the freshly-
-                // opened child scope (Op::OpenLetScope) AFTER every one of
-                // them has already run against the still-current PARENT
-                // ctx. No outer statement-level check for the let-block
-                // node itself (matches evalChildren's own ModularLet
-                // exclusion) -- each assignment gets its own instead,
-                // exactly like evalLetBlock's own per-assignment
-                // checkDebug. The body (n.children) compiles inline,
-                // recursively, against the now-current child ctx -- same
-                // Compiler instance, so nested statements get every bit of
-                // this same real-bytecode treatment too.
+                // Mirrors Evaluator::evalLetBlock (stmt_eval.cpp): the
+                // child scope opens FIRST, then each assignment's RHS is
+                // compiled and stored in source order, so a later binding
+                // sees an earlier one -- `let(a=1, b=a+1) ...` binds b to
+                // 2, exactly as the let-EXPRESSION form does.
+                //
+                // This used to compile every RHS before Op::OpenLetScope
+                // and then store them back-to-front, deliberately denying
+                // that visibility. Real OpenSCAD grants it, and BOSL2
+                // depends on it (isosurface.scad chains five bindings where
+                // each uses the previous).
+                //
+                // No outer statement-level check for the let-block node
+                // itself (matches evalChildren's own ModularLet exclusion)
+                // -- each assignment gets its own, exactly like
+                // evalLetBlock's own per-assignment checkDebug. The body
+                // (n.children) compiles inline, recursively, against the
+                // now-current child ctx.
                 auto& n = static_cast<const oscad::ModularLet&>(stmt);
                 CompileScope exprScope;
+                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
                 for (const auto& assign : n.assignments) {
                     out.push_back({Op::CheckDebugStatement, internNativeStatement(assign.get()), 0, nullptr});
                     compileIsolatedExpr(*assign->expr, out, exprScope);
-                }
-                out.push_back({Op::OpenLetScope, 0, 0, nullptr});
-                // Values pop in REVERSE push order (LIFO) -- iterate the
-                // assignment list backwards so each Op::StoreLetVar is
-                // paired with the value that was actually pushed for IT.
-                for (auto it = n.assignments.rbegin(); it != n.assignments.rend(); ++it) {
-                    out.push_back({Op::StoreLetVar, internName((*it)->name->name), 0, &(*it)->position()});
+                    out.push_back({Op::StoreLetVar, internName(assign->name->name), 0, &assign->position()});
                 }
                 compileStatementList(n.children, out);
                 out.push_back({Op::CloseExprScope, 0, 0, nullptr});

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

@@ -64,7 +64,13 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             std::vector<CSGNode*> childPtrs;
             childPtrs.reserve(node.children.size());
             for (const std::unique_ptr<CSGNode>& c : node.children) childPtrs.push_back(c.get());
+            // Saved and restored rather than left set, exactly as
+            // generateWarnEntry is: a sibling generated afterwards is not
+            // inside this hull.
+            const bool savedInsideHull = insideHull;
+            if (node.isBuiltin && node.kind == "hull") insideHull = true;
             generateTreeImpl(childPtrs);
+            insideHull = savedInsideHull;
 
             applyDimensionRules(node);
 

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/src/stmt_eval.cpp

@@ -155,20 +155,20 @@ void Evaluator::evalFor(const oscad::ModularFor& node, EvalContext& ctx) {
 
 void Evaluator::evalLetBlock(const oscad::ModularLet& node, EvalContext& ctx) {
     EvalContext childCtx = ctx.childCtx(nullptr, std::nullopt, ctx.childrenNodes, ctx.childrenCallerCtx);
-    // ponytail/port-fidelity note: each assignment's RHS is evaluated
-    // against the ORIGINAL `ctx`, not the growing `childCtx` -- unlike the
-    // let() *expression* form's documented sequential visibility
-    // (`let(a=1, b=a+1) expr` sees `a` while evaluating `b`), the
-    // *statement* form `let(a=1, b=a+1) { ... }` does NOT: `b`'s `a+1`
-    // looks `a` up in `ctx`, which doesn't have this let's own `a` binding
-    // yet. This is a direct, deliberate port of the reference's
-    // _eval_let_block, not an oversight -- it evaluates every RHS against
-    // `ctx` in the loop, only ever writing into `child_ctx`.
+    // Each RHS is evaluated against the GROWING childCtx, so a later
+    // binding sees an earlier one -- `let(a=1, b=a+1) ...` binds b to 2.
+    // The statement form behaves exactly like the expression form here.
+    //
+    // This used to evaluate every RHS against the original `ctx` instead,
+    // described in a comment as a deliberate port of the reference's
+    // _eval_let_block. That reference was this project's own earlier
+    // implementation, which had the same bug; real OpenSCAD 2026.02.01
+    // echoes 2, and BOSL2 depends on it heavily -- isosurface.scad chains
+    // five bindings where each uses the previous, and rounding.scad's
+    // join_prism examples do the same.
     for (const auto& assign : node.assignments) {
-        // Checked against the ORIGINAL ctx (like the RHS eval below), not
-        // childCtx -- mirrors _eval_let_block's `_check_debug(assign, ctx)`.
-        checkDebug(*assign, ctx);
-        Value v = evalExprMaybeCompiled(*assign->expr, ctx);
+        checkDebug(*assign, childCtx);
+        Value v = evalExprMaybeCompiled(*assign->expr, childCtx);
         const std::string& name = assign->name->name;
         if (!name.empty() && name[0] == '$') {
             childCtx.dyn->set(name, v);

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/tests/test_bytecode_compiler.cpp

@@ -1889,15 +1889,21 @@ TEST(ModuleBodyCompiles, AssertStatementCompiledFormFailsWithNamedMessage) {
     }
 }
 
-TEST(ModuleBodyCompiles, LetBlockStatementDoesNotSeeItsOwnEarlierSiblingAssignment) {
+TEST(ModuleBodyCompiles, LetBlockStatementSeesItsOwnEarlierSiblingAssignment) {
     ScopedVm vm(true);
-    // The statement form's own documented divergence from let-EXPRESSION
-    // sequential visibility: b's RHS must see the OUTER a (1), not this
-    // same let-block's own a=2 -- b should be 2, not 3.
+    // b's RHS sees THIS let-block's own a=2, not the outer a=1, so b is 3.
+    // The statement form has the same sequential visibility the expression
+    // form does, and the binding still does not escape the block.
+    //
+    // This test previously asserted "ECHO: 2, 2" -- b seeing the outer a --
+    // and called that a documented divergence. It was not: real OpenSCAD
+    // 2026.02.01 echoes "2, 3" then "1", which is what both engines now
+    // produce. BOSL2 depends on the sequential form (isosurface.scad chains
+    // five bindings where each uses the previous).
     EXPECT_EQ(runCapturingEcho("a = 1;\n"
                                "let (a = 2, b = a + 1) { echo(a, b); }\n"
                                "echo(a);\n"),
-              "ECHO: 2, 2\nECHO: 1");
+              "ECHO: 2, 3\nECHO: 1");
 }
 
 TEST(ModuleBodyCompiles, LetBlockStatementIsolatesDollarVarOverrideFromLaterStatements) {

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/tests/test_control_flow.cpp

@@ -428,6 +428,59 @@ TEST(EscapingClosure, CapturelessLiteralStillWorksCompiled) {
 
 // -- let (statement + expression forms) --------------------------------
 
+// The let STATEMENT form has the same sequential visibility as the
+// expression form: a later binding sees an earlier one. Verified against
+// real OpenSCAD 2026.02.01, which echoes 2 for both forms below.
+//
+// This was wrong for a long time, described in-source as a deliberate port
+// of "the reference's _eval_let_block" -- that reference being this
+// project's own earlier implementation, which had the same bug. BOSL2 leans
+// on it: isosurface.scad chains five bindings where each uses the previous,
+// and rounding.scad's join_prism examples do too.
+
+namespace {
+
+void checkLetStatementIsSequential(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    runScript("let (a = 1, b = a + 1) echo(b = b);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: b = 2"}));
+}
+
+void checkLetStatementShadowsWithoutEscaping(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // The inner a=2 is what b sees, and it does not survive the block.
+    runScript("a = 1;\n"
+              "let (a = 2, b = a + 1) echo(inside_a = a, inside_b = b);\n"
+              "echo(after_a = a);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: inside_a = 2, inside_b = 3",
+                                                 "ECHO: after_a = 1"}));
+}
+
+void checkLetStatementChainsSeveralBindings(bool useVm) {
+    ScopedVm vm(useVm);
+    std::vector<std::string> echoed;
+    // The isosurface.scad shape: each binding built from the previous.
+    runScript("let (a = 2, b = a * 3, c = b + a, d = c * b) echo(d = d);\n",
+              [&](const std::string& msg) { echoed.push_back(msg); });
+    EXPECT_EQ(echoed, (std::vector<std::string>{"ECHO: d = 48"}));
+}
+
+} // namespace
+
+TEST(LetStatementScope, IsSequentialCompiled) { checkLetStatementIsSequential(true); }
+TEST(LetStatementScope, IsSequentialInterpreted) { checkLetStatementIsSequential(false); }
+
+TEST(LetStatementScope, ShadowsWithoutEscapingCompiled) { checkLetStatementShadowsWithoutEscaping(true); }
+TEST(LetStatementScope, ShadowsWithoutEscapingInterpreted) { checkLetStatementShadowsWithoutEscaping(false); }
+
+TEST(LetStatementScope, ChainsSeveralBindingsCompiled) { checkLetStatementChainsSeveralBindings(true); }
+TEST(LetStatementScope, ChainsSeveralBindingsInterpreted) { checkLetStatementChainsSeveralBindings(false); }
+
+
 TEST(LetStatement, BindsVisibleInsideBlockOnly) {
     Evaluated e = evalSrc("let(s=3) cube(s);");
     manifold::Box bbox = e.bodies[0].body->BoundingBox();

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/tests/test_csg_tree.cpp

@@ -314,3 +314,81 @@ TEST(WarningTrace, FromClauseNamesOutermostFrameNotImmediateCaller) {
     EXPECT_NE(warning.find("from <string>, line 3"), std::string::npos) << warning;
     EXPECT_EQ(warning.find("from <string>, line 2"), std::string::npos) << warning;
 }
+
+// -- hull() over an open mesh ------------------------------------------
+//
+// A convex hull needs only its input's POINTS; whether the mesh that
+// carried them is closed is irrelevant. BOSL2 leans on this hard:
+// hull_points(pts, fast=true) hands polyhedron() a deliberately garbage
+// face list purely as a vehicle for the vertices, and
+// spheroid(circum=true, style="icosa") goes through that path. Treating
+// the open mesh as display-only left the loose triangles to fall out of
+// hull() un-hulled -- the model rendered as a scatter of shards where the
+// reference produced a solid.
+
+TEST(HullOpenMesh, HullsThePointsOfAMeshThatDoesNotClose) {
+    Evaluated e = evalSrc(
+        "pts = [[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+        "       [0,0,10],[10,0,10],[10,10,10],[0,10,10]];\n"
+        "hull() polyhedron(points=pts, faces=[[0,1,2],[3,4,5],[6,7,0]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u) << "the open mesh must be consumed, not passed through";
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_FALSE(e.bodies[0].isDisplayOnly());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+TEST(HullOpenMesh, AnOpenMeshAndASolidHullTogether) {
+    // The solid's own vertices must survive the switch to the point-based
+    // hull: hulling only the loose points would silently shrink the result.
+    Evaluated e = evalSrc(
+        "hull() {\n"
+        "  polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n"
+        "  translate([0,0,10]) cube(10);\n"
+        "}\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_EQ(e.bodies[0].body->Status(), manifold::Manifold::Error::NoError);
+    // Hull of the z=0 square and the 10..20 cube: a prism, strictly larger
+    // than the cube alone.
+    EXPECT_GT(e.bodies[0].body->Volume(), 1000.0);
+}
+
+TEST(HullOpenMesh, AnOpenMeshOutsideAHullStillPassesThroughUntouched) {
+    Evaluated e = evalSrc(
+        "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n");
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].isDisplayOnly()) << "only hull() may consume it";
+}
+
+TEST(HullOpenMesh, NoWarningForAnOpenMeshInsideAHull) {
+    // The reference is silent here, and BOSL2 reaches this on an everyday
+    // spheroid(circum=true, style="icosa") -- warning would cry wolf.
+    std::string warning;
+    evalSrc("hull() polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],\n"
+            "                          [0,0,10],[10,0,10],[10,10,10],[0,10,10]],\n"
+            "                  faces=[[0,1,2],[3,4,5],[6,7,0]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, SuppressionCoversTheWholeSubtreeNotJustDirectChildren) {
+    std::string warning;
+    evalSrc("hull() { translate([0,0,1]) polyhedron(\n"
+            "    points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]); cube(1); }\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(HullOpenMesh, ASiblingAfterAHullStillWarns) {
+    // The flag is restored on the way out; an open mesh that is NOT hulled
+    // is still a real mistake.
+    std::string warning;
+    evalSrc("hull() cube(1);\n"
+            "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[[0,1,2]]);\n",
+            [&](const std::string& m) { if (warning.empty()) warning = m; });
+    EXPECT_NE(warning.find("mesh is not closed"), std::string::npos) << warning;
+}

{openscad_cpp_evaluator-0.53.0 → openscad_cpp_evaluator-0.55.0}/tests/test_primitives.cpp

@@ -211,6 +211,32 @@ TEST(Polyhedron, OpenMeshIsKeptForDisplayAndWarns) {
 // The originalID is what maps a picked triangle back to its source line, so
 // a display-only body has to carry one or clicking it would select nothing
 // -- precisely when a user most wants to be shown the offending code.
+// A polyhedron with points but NO faces is empty geometry, not a failure.
+// BOSL2's debug_vnf() passes [verts, []] to draw vertex labels with no
+// surface at all, and real OpenSCAD 2026.02.01 accepts
+// `polyhedron(points=..., faces=[])` silently. This used to report the
+// empty mesh as NotManifold and discard it with a warning, which failed
+// four BOSL2 geometry.scad examples.
+TEST(Polyhedron, NoFacesIsEmptyGeometryAndSilent) {
+    std::string warning;
+    Evaluated e = evalSrc("polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0]], faces=[]);",
+                          [&](const std::string& m) { warning = m; });
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].body->IsEmpty());
+    EXPECT_FALSE(e.bodies[0].isDisplayOnly());   // nothing to display, not an open surface
+    EXPECT_EQ(warning, "") << warning;
+}
+
+TEST(Polyhedron, NoPointsAndNoFacesIsAlsoSilent) {
+    std::string warning;
+    Evaluated e = evalSrc("polyhedron(points=[], faces=[]);",
+                          [&](const std::string& m) { warning = m; });
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].body->IsEmpty());
+    EXPECT_EQ(warning, "") << warning;
+}
+
 TEST(Polyhedron, OpenMeshCarriesAnOriginalIdForPicking) {
     Evaluated e = evalSrc(kOpenCube);
     ASSERT_EQ(e.bodies.size(), 1u);