openscad-cpp-evaluator 0.14.0__tar.gz → 0.15.0__tar.gz

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/bindings/module.cpp

@@ -129,7 +129,11 @@ const char* roleToString(oscadeval::BodyRole role) {
 // tri_verts (nTri, 3), run_original_id (nRun,), run_index (nRun+1,) -- the
 // same flat 3*triangle units manifold3d's own run_index uses).
 nb::dict bodyToDict(oscadeval::ColoredBody& cb) {
-    manifold::MeshGL mesh = cb.body->GetMeshGL();
+    // A display-only body's Manifold is empty by construction, so its
+    // GetMeshGL() would hand back nothing -- take the raw triangle soup
+    // that failed to build instead. Everything downstream reads plain
+    // arrays, so the two cases are indistinguishable from here on.
+    manifold::MeshGL mesh = cb.isDisplayOnly() ? *cb.rawMesh : cb.body->GetMeshGL();
     const size_t numProp = mesh.numProp;
     const size_t numVert = numProp ? mesh.vertProperties.size() / numProp : 0;
     const size_t numTri = mesh.triVerts.size() / 3;
@@ -184,7 +188,9 @@ void collectIdSpans(const oscadeval::Evaluator& ev, std::vector<IdSpan>& out) {
 nb::list bodiesToList(std::vector<oscadeval::ColoredBody>& bodies) {
     nb::list out;
     for (oscadeval::ColoredBody& cb : bodies) {
-        if (!cb.body || cb.body->IsEmpty()) continue;
+        // isDisplayOnly() bodies are ALWAYS IsEmpty() -- that's what made
+        // an open polyhedron() silently vanish here rather than render.
+        if (!cb.isDisplayOnly() && (!cb.body || cb.body->IsEmpty())) continue;
         out.append(bodyToDict(cb));
     }
     return out;
@@ -210,7 +216,7 @@ nb::object csgNodeToPy(const oscadeval::CSGNode& node) {
     for (const auto& [k, v] : node.params) params[nb::str(k.c_str())] = valueToPy(v);
     nb::list bodies;
     for (const oscadeval::ColoredBody& cb : node.bodies) {
-        if (!cb.body || cb.body->IsEmpty()) continue;
+        if (!cb.isDisplayOnly() && (!cb.body || cb.body->IsEmpty())) continue;
         // ColoredBody here is const in this walk (tree ownership stays with
         // the caller) -- GetMeshGL() itself is logically read-only, so a
         // const_cast here is safe/local, mirroring bodyToDict's mutating

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -26,6 +26,27 @@ struct ColoredBody {
     bool flatPreview = false;
     BodyRole role = BodyRole::Normal;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
+
+    // Set ONLY when a mesh could not be built into a valid Manifold -- in
+    // practice a polyhedron() whose faces don't close the surface (it has
+    // boundary edges), which Manifold reports by returning an *empty* body
+    // with Status() == NotManifold rather than by failing. Note the status
+    // name is misleading: a closed mesh with reversed winding, non-manifold
+    // vertices or self-intersections builds fine; only an OPEN one lands
+    // here.
+    //
+    // Carrying the raw triangle soup alongside lets the renderer still draw
+    // what the script described, which is far more use for spotting the
+    // missing face than an empty viewport. `body` is deliberately left set
+    // (and empty), so every existing `cb.body->...` path keeps working.
+    //
+    // Such a body is display-only: it can never take part in a CSG
+    // operation, since there is no Manifold for Manifold to operate on.
+    // splitByRole() pulls it aside much as it does a `%` background body,
+    // and the CSG/hull/minkowski generators re-join it unchanged.
+    std::optional<manifold::MeshGL> rawMesh;
+
+    bool isDisplayOnly() const { return rawMesh.has_value(); }
 };
 
 // `EvalContext::color`/CSGParams round-trip: a resolve function reads

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -236,6 +236,18 @@ public:
     // comment for why that reference exists at all).
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
+    // tagGenerated()'s counterpart for a mesh Manifold refused to build --
+    // an open polyhedron(). Returns a display-only ColoredBody (see
+    // ColoredBody::rawMesh) carrying the triangle soup as-is, so it can
+    // still be drawn even though no CSG operation can ever touch it.
+    //
+    // A failed Manifold has no run IDs of its own, so one is reserved here
+    // and written onto the raw mesh -- otherwise the body would be
+    // invisible to selection and to the originalID -> AST node mapping
+    // that drives click-to-source, which is exactly when a user most wants
+    // to click the broken thing and be shown the line that made it.
+    ColoredBody tagDisplayOnly(manifold::MeshGL mesh, const oscad::ASTNode& node, const Value& colorValue);
+
     // Raises an OpenSCAD-level runtime error: throws EvalError with the
     // formatted "ERROR: {msg}{TRACE lines}" message (see eval_error.hpp),
     // walking the real user function/module call stack for the TRACE lines

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/builtins/booleans.cpp

@@ -27,8 +27,19 @@ RoleSplit splitByRole(const std::vector<ColoredBody>& bodies) {
     for (const ColoredBody& c : bodies) {
         if (c.role == BodyRole::Background) r.background.push_back(c);
     }
+    // Checked before the foreground sweep below and excluded from it: a
+    // display-only body has an empty Manifold, so letting it reach a
+    // boolean would silently zero the whole operation (the same failure
+    // mode invalid operands caused before they were filtered out).
     for (const ColoredBody& c : bodies) {
-        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) r.foreground.push_back(c);
+        if (c.isDisplayOnly() && c.role != BodyRole::Background && c.role != BodyRole::ShowOnly) {
+            r.displayOnly.push_back(c);
+        }
+    }
+    for (const ColoredBody& c : bodies) {
+        if (c.role != BodyRole::Background && c.role != BodyRole::ShowOnly && !c.isDisplayOnly()) {
+            r.foreground.push_back(c);
+        }
     }
     for (const ColoredBody& c : r.foreground) {
         if (c.role == BodyRole::Highlight) r.highlight.push_back(c);
@@ -160,7 +171,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     const std::string& op = std::get<std::string>(params.at("op"));
     const auto& groupSizes = std::get<ListPtr>(params.at("group_sizes"))->items;
 
-    std::vector<ColoredBody> allBg, allHi, allSo;
+    std::vector<ColoredBody> allBg, allHi, allSo, allDo;
     std::optional<ColoredBody> csgResult;
     size_t idx = 0;
 
@@ -173,6 +184,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         allBg.insert(allBg.end(), split.background.begin(), split.background.end());
         allHi.insert(allHi.end(), split.highlight.begin(), split.highlight.end());
         allSo.insert(allSo.end(), split.showOnly.begin(), split.showOnly.end());
+        allDo.insert(allDo.end(), split.displayOnly.begin(), split.displayOnly.end());
 
         std::vector<ColoredBody> bodies3d, sections2d;
         for (const ColoredBody& c : split.foreground) {
@@ -251,6 +263,7 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());
+    result.insert(result.end(), allDo.begin(), allDo.end());
     return result;
 }
 

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/builtins/builtins.hpp

@@ -77,11 +77,23 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params,
 // splitting/2D-merge logic.
 struct RoleSplit {
     std::vector<ColoredBody> background;
-    std::vector<ColoredBody> foreground; // role != Background && role != ShowOnly
+    std::vector<ColoredBody> foreground; // role != Background && role != ShowOnly, and not display-only
     std::vector<ColoredBody> highlight;  // the subset of `foreground` that's role == Highlight
     std::vector<ColoredBody> showOnly;
+    // Bodies with no Manifold to operate on (an open polyhedron -- see
+    // ColoredBody::rawMesh). Split out for the same reason showOnly is:
+    // they must survive a CSG/hull/minkowski step untouched rather than be
+    // merged into it, since there is nothing to merge. Kept separate from
+    // `background` because they render as ordinary geometry, not as a
+    // translucent ghost.
+    std::vector<ColoredBody> displayOnly;
 };
 RoleSplit splitByRole(const std::vector<ColoredBody>& bodies);
+
+// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
+// not enabled in this build -- so this mirrors it. Shared by import.cpp and
+// primitives_3d.cpp, both of which report why a mesh wouldn't build.
+std::string manifoldErrorName(manifold::Manifold::Error e);
 std::optional<manifold::CrossSection> toCrossSection(const std::vector<ColoredBody>& bodies);
 
 // Merges a statement's bodies into one (3D union, else 2D union, else an

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/builtins/import.cpp

@@ -49,29 +49,6 @@ LoadedMesh loadMeshByExt(const std::string& path, const std::string& ext) {
 
 bool isMeshExt(const std::string& ext) { return ext == ".stl" || ext == ".obj" || ext == ".off" || ext == ".3mf"; }
 
-// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
-// not enabled in this project's build -- so this mirrors it locally for the
-// not-manifold warning message.
-std::string manifoldErrorName(manifold::Manifold::Error e) {
-    switch (e) {
-        case manifold::Manifold::Error::NoError: return "NoError";
-        case manifold::Manifold::Error::NonFiniteVertex: return "NonFiniteVertex";
-        case manifold::Manifold::Error::NotManifold: return "NotManifold";
-        case manifold::Manifold::Error::VertexOutOfBounds: return "VertexOutOfBounds";
-        case manifold::Manifold::Error::PropertiesWrongLength: return "PropertiesWrongLength";
-        case manifold::Manifold::Error::MissingPositionProperties: return "MissingPositionProperties";
-        case manifold::Manifold::Error::MergeVectorsDifferentLengths: return "MergeVectorsDifferentLengths";
-        case manifold::Manifold::Error::MergeIndexOutOfBounds: return "MergeIndexOutOfBounds";
-        case manifold::Manifold::Error::TransformWrongLength: return "TransformWrongLength";
-        case manifold::Manifold::Error::RunIndexWrongLength: return "RunIndexWrongLength";
-        case manifold::Manifold::Error::FaceIDWrongLength: return "FaceIDWrongLength";
-        case manifold::Manifold::Error::InvalidConstruction: return "InvalidConstruction";
-        case manifold::Manifold::Error::ResultTooLarge: return "ResultTooLarge";
-        case manifold::Manifold::Error::InvalidTangents: return "InvalidTangents";
-        case manifold::Manifold::Error::Cancelled: return "Cancelled";
-    }
-    return "Unknown";
-}
 
 Value jsonToValue(const nlohmann::ordered_json& j) {
     if (j.is_boolean()) return Value{j.get<bool>()};
@@ -135,6 +112,30 @@ Value meshToVnf(const LoadedMesh& mesh) {
 
 } // namespace
 
+// manifold::ToString(Manifold::Error) only exists under MANIFOLD_DEBUG --
+// not enabled in this project's build -- so this mirrors it locally for the
+// not-manifold warning message.
+std::string manifoldErrorName(manifold::Manifold::Error e) {
+    switch (e) {
+        case manifold::Manifold::Error::NoError: return "NoError";
+        case manifold::Manifold::Error::NonFiniteVertex: return "NonFiniteVertex";
+        case manifold::Manifold::Error::NotManifold: return "NotManifold";
+        case manifold::Manifold::Error::VertexOutOfBounds: return "VertexOutOfBounds";
+        case manifold::Manifold::Error::PropertiesWrongLength: return "PropertiesWrongLength";
+        case manifold::Manifold::Error::MissingPositionProperties: return "MissingPositionProperties";
+        case manifold::Manifold::Error::MergeVectorsDifferentLengths: return "MergeVectorsDifferentLengths";
+        case manifold::Manifold::Error::MergeIndexOutOfBounds: return "MergeIndexOutOfBounds";
+        case manifold::Manifold::Error::TransformWrongLength: return "TransformWrongLength";
+        case manifold::Manifold::Error::RunIndexWrongLength: return "RunIndexWrongLength";
+        case manifold::Manifold::Error::FaceIDWrongLength: return "FaceIDWrongLength";
+        case manifold::Manifold::Error::InvalidConstruction: return "InvalidConstruction";
+        case manifold::Manifold::Error::ResultTooLarge: return "ResultTooLarge";
+        case manifold::Manifold::Error::InvalidTangents: return "InvalidTangents";
+        case manifold::Manifold::Error::Cancelled: return "Cancelled";
+    }
+    return "Unknown";
+}
+
 namespace {
 
 Value contoursToValue(const std::vector<Contour2d>& contours) {
@@ -269,7 +270,15 @@ std::vector<ColoredBody> generateImport(Evaluator& ev, const CSGParams& params,
 
     manifold::Manifold body(mesh);
     if (body.Status() != manifold::Manifold::Error::NoError) {
-        ev.warn("import: mesh is not manifold (" + manifoldErrorName(body.Status()) + ")", &node.position());
+        // Same treatment as an open polyhedron() (see generatePolyhedron):
+        // keep the triangles so the file can still be LOOKED at. Previously
+        // this warned and then handed back an empty body, which was dropped
+        // downstream -- so a broken STL warned once and showed nothing,
+        // giving no way to see what was actually wrong with it.
+        ev.warn("import: mesh is not a closed solid (" + manifoldErrorName(body.Status()) +
+                    "); drawing it as a surface, but it cannot take part in any CSG operation",
+                &node.position());
+        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
     }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/builtins/primitives_3d.cpp

@@ -14,6 +14,45 @@ namespace oscadeval {
 
 namespace {
 bool isUndef(const Value& v) { return std::holds_alternative<std::monostate>(v); }
+
+// Edges used by an odd number of triangles -- i.e. the mesh's open border.
+// A closed solid has none; every edge is shared by exactly two faces.
+//
+// Counted on the UNDIRECTED edge (sorted endpoints) rather than the
+// directed half-edge, so a hole reads as a hole regardless of winding:
+// counting directed edges would also flag a merely back-to-front face,
+// which builds into a perfectly valid solid and is not what this reports.
+// Whether a mesh Manifold rejected is nonetheless safe to hand to a
+// renderer. Only NotManifold qualifies: it means "the triangles are fine,
+// they just don't close a solid", which is exactly the open-surface case
+// worth drawing. Every other status (NonFiniteVertex above all, but also
+// VertexOutOfBounds and friends) means the vertex data itself is broken --
+// drawing NaN coordinates would poison the scene bounding box and send the
+// camera auto-fit to infinity, which is worse than showing nothing. The
+// explicit finite check is belt-and-braces, since nothing documents that a
+// NotManifold mesh can't ALSO contain a NaN.
+bool isDrawableFailure(const manifold::Manifold& body, const manifold::MeshGL& mesh) {
+    if (body.Status() != manifold::Manifold::Error::NotManifold) return false;
+    if (mesh.triVerts.empty()) return false;
+    return std::all_of(mesh.vertProperties.begin(), mesh.vertProperties.end(),
+                        [](float v) { return std::isfinite(v); });
+}
+
+size_t countBoundaryEdges(const manifold::MeshGL& mesh) {
+    std::map<std::pair<uint32_t, uint32_t>, int> uses;
+    for (size_t i = 0; i + 2 < mesh.triVerts.size(); i += 3) {
+        const uint32_t v[3] = {mesh.triVerts[i], mesh.triVerts[i + 1], mesh.triVerts[i + 2]};
+        for (int e = 0; e < 3; ++e) {
+            const uint32_t a = v[e], b = v[(e + 1) % 3];
+            ++uses[{std::min(a, b), std::max(a, b)}];
+        }
+    }
+    size_t open = 0;
+    for (const auto& [edge, count] : uses) {
+        if (count % 2 != 0) ++open;
+    }
+    return open;
+}
 } // namespace
 
 // cube(size = 1, center = false) -- mirrors _resolve_cube/_generate_cube.
@@ -292,6 +331,31 @@ std::vector<ColoredBody> generatePolyhedron(Evaluator& ev, const CSGParams& para
         mesh.triVerts.push_back(static_cast<uint32_t>(std::get<double>(t)));
     }
     manifold::Manifold body(mesh);
+    if (isDrawableFailure(body, mesh)) {
+        // An open surface -- faces that don't close the solid. Manifold
+        // signals that by returning an EMPTY body rather than throwing, so
+        // without this branch the polyhedron simply vanishes from the
+        // render with nothing said, leaving the author to guess which face
+        // they forgot.
+        //
+        // Report the boundary-edge count rather than Manifold's own
+        // "NotManifold" status string, which is actively misleading here: a
+        // 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());
+        return {ev.tagDisplayOnly(std::move(mesh), node, params.at("color"))};
+    }
+    if (body.Status() != manifold::Manifold::Error::NoError) {
+        // Broken vertex data rather than merely-open topology (a NaN
+        // coordinate, an out-of-range index). Not drawable, so this keeps
+        // the old drop-it behaviour -- but says so, which it never used to.
+        ev.warn(std::string("polyhedron: ") + manifoldErrorName(body.Status()) + "; geometry discarded",
+                &node.position());
+    }
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }
 

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/builtins/topology.cpp

@@ -61,6 +61,7 @@ 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());
     return result;
 }
 
@@ -89,6 +90,7 @@ std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams&, cons
     passthrough.insert(passthrough.end(), split.background.begin(), split.background.end());
     passthrough.insert(passthrough.end(), split.highlight.begin(), split.highlight.end());
     passthrough.insert(passthrough.end(), split.showOnly.begin(), split.showOnly.end());
+    passthrough.insert(passthrough.end(), split.displayOnly.begin(), split.displayOnly.end());
 
     if (bodies3d.empty()) return passthrough;
     if (bodies3d.size() == 1) {

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/src/csg_generate.cpp

@@ -110,4 +110,27 @@ ColoredBody Evaluator::tagGenerated(manifold::Manifold body, const oscad::ASTNod
     return cb;
 }
 
+ColoredBody Evaluator::tagDisplayOnly(manifold::MeshGL mesh, const oscad::ASTNode& node, const Value& colorValue) {
+    const std::optional<std::array<float, 4>> color = valueToColor(colorValue);
+
+    // A Manifold that failed to build carries no run IDs, so reserve one
+    // and describe the whole soup as a single run. ReserveIDs() draws from
+    // the same global counter Manifold hands to real bodies, so an ID
+    // minted here can never collide with one of theirs.
+    const uint32_t originalId = manifold::Manifold::ReserveIDs(1);
+    mesh.runOriginalID = {originalId};
+    mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+    idToNode[originalId] = &node;
+    idToColor[originalId] = color;
+
+    ColoredBody cb;
+    // Left set-but-empty rather than nullopt: consumers dereference
+    // cb.body unconditionally, and an empty Manifold is also the honest
+    // answer to "what solid is this?" -- there isn't one.
+    cb.body = manifold::Manifold();
+    cb.color = color;
+    cb.rawMesh = std::move(mesh);
+    return cb;
+}
+
 } // namespace oscadeval

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/tests/test_import_export.cpp

@@ -137,7 +137,14 @@ TEST(ImportModuleContext, NonManifoldMeshWarns) {
     }
     std::string lastWarning;
     Evaluated e = evalSrc("import(\"" + path.string() + "\");", [&](const std::string& msg) { lastWarning = msg; });
-    EXPECT_NE(lastWarning.find("import: mesh is not manifold"), std::string::npos);
+    EXPECT_NE(lastWarning.find("import: mesh is not a closed solid"), std::string::npos);
+    // The triangle is now handed back for display rather than dropped: a
+    // file that warns once and then shows nothing gives no way to see what
+    // is actually wrong with it. It carries no Manifold, so it still can't
+    // take part in a CSG operation.
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].isDisplayOnly());
+    EXPECT_EQ(e.bodies[0].rawMesh->triVerts.size(), 3u);
     std::filesystem::remove(path);
 }
 

{openscad_cpp_evaluator-0.14.0 → openscad_cpp_evaluator-0.15.0}/tests/test_primitives.cpp

@@ -181,3 +181,95 @@ TEST(Primitives2d, PolygonWithPathsSelectsIndexedContour) {
     Evaluated e = evalSrc("polygon(points=[[0,0],[2,0],[2,2],[0,2]], paths=[[0,1,2,3]]);");
     EXPECT_NEAR(e.bodies[0].section->Area(), 4.0, 1e-9);
 }
+
+// -- open (non-closed) polyhedron: display-only ---------------------------
+
+namespace {
+// A cube with the -x face omitted: five quads, so four boundary edges.
+constexpr const char* kOpenCube =
+    "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],"
+    "                   [0,0,10],[10,0,10],[10,10,10],[0,10,10]],"
+    "           faces=[[0,1,2,3],[4,7,6,5],[0,4,5,1],[1,5,6,2],[2,6,7,3]]);";
+} // namespace
+
+// Manifold cannot represent an open surface, but silently rendering nothing
+// left no way to tell a broken polyhedron from a missing one. The triangles
+// are kept for display instead, tagged so nothing tries to CSG them.
+TEST(Polyhedron, OpenMeshIsKeptForDisplayAndWarns) {
+    std::string warning;
+    Evaluated e = evalSrc(kOpenCube, [&](const std::string& m) { warning = m; });
+
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_TRUE(e.bodies[0].isDisplayOnly());
+    EXPECT_TRUE(e.bodies[0].body->IsEmpty());       // no solid, by definition
+    EXPECT_EQ(e.bodies[0].rawMesh->triVerts.size(), 10u * 3u);  // 5 quads -> 10 tris
+
+    EXPECT_NE(warning.find("not closed"), std::string::npos) << warning;
+    EXPECT_NE(warning.find("4 boundary edge"), std::string::npos) << warning;
+}
+
+// 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.
+TEST(Polyhedron, OpenMeshCarriesAnOriginalIdForPicking) {
+    Evaluated e = evalSrc(kOpenCube);
+    ASSERT_EQ(e.bodies.size(), 1u);
+    const manifold::MeshGL& mesh = *e.bodies[0].rawMesh;
+    ASSERT_EQ(mesh.runOriginalID.size(), 1u);
+    EXPECT_EQ(e.ev.idToNode.count(mesh.runOriginalID[0]), 1u);
+    ASSERT_EQ(mesh.runIndex.size(), 2u);
+    EXPECT_EQ(mesh.runIndex[1], mesh.triVerts.size());
+}
+
+// A closed mesh is still a solid however badly it's wound or built -- only
+// an OPEN one takes the display-only path. Manifold's own status name for
+// that case ("NotManifold") reads as though it covers these too; it doesn't.
+TEST(Polyhedron, ClosedButUglyMeshesStillBuildSolids) {
+    // All faces reversed (inside-out).
+    Evaluated inverted = evalSrc(
+        "polyhedron(points=[[0,0,0],[10,0,0],[10,10,0],[0,10,0],"
+        "                   [0,0,10],[10,0,10],[10,10,10],[0,10,10]],"
+        "           faces=[[3,2,1,0],[5,6,7,4],[1,5,4,0],[2,6,5,1],[3,7,6,2],[0,4,7,3]]);");
+    ASSERT_EQ(inverted.bodies.size(), 1u);
+    EXPECT_FALSE(inverted.bodies[0].isDisplayOnly());
+
+    // Two tetrahedra meeting at a single (non-manifold) vertex.
+    Evaluated pinched = evalSrc(
+        "polyhedron(points=[[0,0,0],[10,0,0],[0,10,0],[0,0,10],"
+        "                   [0,0,0],[-10,0,0],[0,-10,0],[0,0,-10]],"
+        "           faces=[[0,2,1],[0,1,3],[1,2,3],[0,3,2],"
+        "                  [4,6,5],[4,5,7],[5,6,7],[4,7,6]]);");
+    ASSERT_EQ(pinched.bodies.size(), 1u);
+    EXPECT_FALSE(pinched.bodies[0].isDisplayOnly());
+}
+
+// A NaN coordinate is NOT drawable: it would poison the scene bounding box
+// and send a renderer's camera auto-fit to infinity. Such a mesh keeps the
+// old drop-it behaviour -- but now says so instead of vanishing mutely.
+TEST(Polyhedron, NonFiniteVertexIsDiscardedNotDisplayed) {
+    std::string warning;
+    Evaluated e = evalSrc("polyhedron(points=[[0,0,0],[2,0,0],[0,2,0],[0/0,0,2]],"
+                          "           faces=[[0,1,2],[0,3,1],[0,2,3],[1,3,2]]);",
+                          [&](const std::string& m) { warning = m; });
+    for (const ColoredBody& b : e.bodies) EXPECT_FALSE(b.isDisplayOnly());
+    EXPECT_NE(warning.find("NonFiniteVertex"), std::string::npos) << warning;
+}
+
+// It has no Manifold, so a boolean would have nothing to operate on. It is
+// pulled aside like a `%` body and re-joined afterwards, leaving its valid
+// siblings to merge normally.
+TEST(Polyhedron, OpenMeshIsExcludedFromCsgButSurvivesIt) {
+    Evaluated e = evalSrc(std::string("union() { translate([50,0,0]) cube(4); ") + kOpenCube + " }");
+    ASSERT_EQ(e.bodies.size(), 2u);
+
+    int solids = 0, displayOnly = 0;
+    for (const ColoredBody& b : e.bodies) {
+        if (b.isDisplayOnly()) ++displayOnly;
+        else if (b.body && !b.body->IsEmpty()) {
+            ++solids;
+            EXPECT_NEAR(b.body->Volume(), 64.0, 1e-6);  // the cube, unharmed
+        }
+    }
+    EXPECT_EQ(solids, 1);
+    EXPECT_EQ(displayOnly, 1);
+}