openscad-cpp-evaluator 1.7.0__tar.gz → 1.8.0__tar.gz

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/bindings/module.cpp

@@ -357,7 +357,7 @@ struct Geometry {
 // exportModel, with the path/format/warnings marshalling. Releases the GIL:
 // a large export is seconds of Manifold work with no Python involved.
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers) {
+                        bool stripSlivers, bool splitComponents) {
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
@@ -365,6 +365,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.format = format;
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
+        opts.splitComponents = splitComponents;
         warnings = oscadeval::exportModel(path, geom.bodies, opts);
     }
     nb::list out;
@@ -786,10 +787,14 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     m.def("export_model", &exportModelPy, nb::arg("path"), nb::arg("geometry"), nb::arg("format") = std::string(),
           nb::arg("ascii_stl") = false, nb::arg("strip_slivers") = true,
+          nb::arg("split_components") = false,
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
-          "file cannot be opened.");
+          "file cannot be opened.\n\n"
+          "`split_components` gives every disconnected piece its own object in the multi-object formats "
+          "(3MF, AMF, OBJ, PLY, VRML, X3D). Off by default, matching OpenSCAD, which writes one object "
+          "per colour however many pieces it is in.");
 
     m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
           "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -816,6 +816,15 @@ struct CompiledChunk {
         // and copying it back out.
         struct ArgBind {
             int paramIndex = -1;    // >=0: this argument binds that parameter
+            // Any FURTHER parameters of the same name. Normally empty, but a
+            // declaration may repeat a parameter name -- BOSL2's
+            // regular_prism() declares both `length` and `height` twice --
+            // and the name-matching path this replaced bound every one of
+            // them, because it walked the parameter list asking "is there a
+            // bound argument called this?" rather than the other way round.
+            // Binding only the first silently left the body reading undef
+            // from whichever slot the duplicate name finally resolved to.
+            std::vector<int> alsoParams;
             bool toDyn = false;     // instead bind by name into ctx.dyn ($-named, undeclared)
             bool warnUnexpectedNamed = false;
             bool warnTooManyPositional = false;

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/include/openscad_cpp_evaluator/export.hpp

@@ -39,13 +39,21 @@ struct ExportObject {
 //      `color("red") body(); color("blue") detail();` leaves the detail
 //      whole. Only the invisible interior is affected: the visible surface
 //      is identical either way.
-//   3. One object per connected component.
+//   3. One object per connected component -- OPTIONAL, and off by default.
+//      Rules 1 and 2 are about correctness; this one is presentation, and
+//      it is the one that diverges from OpenSCAD, which writes a single
+//      object however many disjoint pieces the model has. Splitting turned
+//      `cube(10); translate([20,0,0]) cube(10);` into two 3MF objects and a
+//      multiboard tile into hundreds, which slicers list individually and
+//      Prusa Slicer complains about (issue #319). Ask for it when separate
+//      pieces are what you want; leave it off to match OpenSCAD.
 //
 // A body Manifold rejected (an open shell is not a solid) can take part in
 // none of that: it keeps its own triangles and its own object, and its
 // 1-based index is appended to `openParts` for the caller to warn about.
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
-                                                std::vector<int>* openParts = nullptr);
+                                                std::vector<int>* openParts = nullptr,
+                                                bool splitComponents = false);
 
 // Writes a binary STL: composes every body's mesh into one solid (bodies
 // with no `.body` -- 2D-only sections -- or an empty Manifold are
@@ -130,6 +138,12 @@ struct ExportOptions {
     // break no topology, but slicers commonly discard them and are then
     // left with the holes their removal opens.
     bool stripSlivers = true;
+    // Rule 3 of splitBodiesForExport: give every disconnected piece its own
+    // object in the multi-object formats (3MF, AMF, OBJ, PLY, VRML, X3D).
+    // Off matches OpenSCAD, which writes one object per colour however many
+    // pieces it is in; see that function's own comment for why the default
+    // moved here.
+    bool splitComponents = false;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/python/openscad_cpp_evaluator/__init__.py

@@ -292,13 +292,13 @@ def strip_slivers(verts, tris):
 
 
 def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
-                 strip_slivers: bool = True) -> list:
+                 strip_slivers: bool = True, split_components: bool = False) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
     `.geometry` -- the evaluated bodies, still on the C++ side. Export has
     to do real CSG (the implicit top-level union, the per-colour volume
-    claim, the connected-component split), and going through the flattened
+    claim), and going through the flattened
     arrays the renderer gets would mean rebuilding every Manifold first:
     ~146ms on a 224k-triangle model, and Manifold's own provenance lost
     along the way.
@@ -309,9 +309,13 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     here refuses to write: a deliberately open surface is a legitimate
     export. Raises EvalError when there is no geometry, the format is
     unknown, or the file cannot be opened.
+
+    `split_components` gives every disconnected piece its own object in the
+    multi-object formats. Off by default, which is what OpenSCAD writes.
     """
     try:
-        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers))
+        return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
+                                       split_components))
     except Exception as e:
         raise EvalError(str(e)) from e
 

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/src/bytecode_compiler.cpp

@@ -20,6 +20,22 @@
 namespace oscadeval {
 
 namespace {
+// Records every parameter called `name`, not just the first. See
+// CompiledChunk::CallSite::ArgBind::alsoParams for why there can be more
+// than one.
+void bindEveryParamNamed(CompiledChunk::CallSite::ArgBind& b,
+                         const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& params,
+                         const std::string& name) {
+    for (size_t p = 0; p < params.size(); ++p) {
+        if (params[p]->name->name != name) continue;
+        if (b.paramIndex < 0) {
+            b.paramIndex = static_cast<int>(p);
+        } else {
+            b.alsoParams.push_back(static_cast<int>(p));
+        }
+    }
+}
+
 // Replays buildBoundArgs' own positional/named matching rule (bytecode_vm.cpp)
 // against a parameter list known at compile time, recording the answer per
 // argument instead of recomputing it per call. The rule, unchanged: a named
@@ -38,19 +54,16 @@ void planCallSiteArgs(CompiledChunk::CallSite& site,
         CompiledChunk::CallSite::ArgBind& b = site.argBinds[i];
         if (site.argNames[i]) {
             const std::string& name = *site.argNames[i];
-            int found = -1;
-            for (size_t p = 0; p < nparams; ++p) {
-                if (params[p]->name->name == name) {
-                    found = static_cast<int>(p);
-                    break;
-                }
-            }
-            b.paramIndex = found;
-            b.warnUnexpectedNamed = (found < 0) && !isConfigVariable(name);
-            b.toDyn = (found < 0) && !name.empty() && name[0] == '$';
+            bindEveryParamNamed(b, params, name);
+            const bool found = b.paramIndex >= 0;
+            b.warnUnexpectedNamed = !found && !isConfigVariable(name);
+            b.toDyn = !found && !name.empty() && name[0] == '$';
         } else {
             if (positionalIdx < nparams) {
-                b.paramIndex = static_cast<int>(positionalIdx);
+                // By NAME, not just by index: a positional argument landing on
+                // a repeated name filled every parameter of that name too,
+                // because the old path keyed its bound arguments by name.
+                bindEveryParamNamed(b, params, params[positionalIdx]->name->name);
             } else if (positionalIdx == nparams) {
                 b.warnTooManyPositional = true;
             }

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/src/bytecode_vm.cpp

@@ -151,6 +151,17 @@ void bindPlannedArgsIntoFrame(const CompiledChunk& chunk, const CompiledChunk::C
     for (size_t i = 0; i < argCount; ++i) {
         const CompiledChunk::CallSite::ArgBind& b = site.argBinds[i];
         if (b.paramIndex >= 0) {
+            // The duplicate-name case (alsoParams) needs the value more than
+            // once, so it is copied there and only the last one moves.
+            for (const int extra : b.alsoParams) {
+                const CompiledChunk::Param& e = chunk.params[static_cast<size_t>(extra)];
+                if (e.isDyn) {
+                    ctx.dyn->set(e.name, args[i]);
+                } else {
+                    frame.slots[static_cast<size_t>(e.slot)] = args[i];
+                }
+                frame.bound[static_cast<size_t>(extra)] = true;
+            }
             const CompiledChunk::Param& p = chunk.params[static_cast<size_t>(b.paramIndex)];
             if (p.isDyn) {
                 ctx.dyn->set(p.name, std::move(args[i]));

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/src/export.cpp

@@ -418,7 +418,8 @@ std::vector<std::array<float, 4>> carryTriColors(const std::vector<std::array<fl
 
 } // namespace
 
-std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts) {
+std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
+                                                bool splitComponents) {
     struct Solid {
         manifold::Manifold man;
         std::optional<std::array<float, 4>> color;
@@ -545,9 +546,12 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
 
     std::vector<ExportObject> out;
     for (const Claimed& g : claimedGroups) {
-        // Decompose() is the rule-3 split. A single-component solid comes
-        // back as a one-element list, so there is no special case here.
-        std::vector<manifold::Manifold> parts = g.man.Decompose();
+        // Decompose() is the rule-3 split, and it is opt-in: without it this
+        // colour group stays one object however many disjoint pieces it is
+        // in, which is what OpenSCAD writes. A single-component solid comes
+        // back as a one-element list either way, so there is no special case.
+        std::vector<manifold::Manifold> parts;
+        if (splitComponents) parts = g.man.Decompose();
         if (parts.empty()) parts.push_back(g.man);
         for (const manifold::Manifold& part : parts) {
             if (part.IsEmpty()) continue;
@@ -1022,7 +1026,7 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         // its own -- that is what the file contains.
         for (std::string& w : checkExportBodies(bodies)) warnings.push_back(std::move(w));
         std::vector<int> openParts;
-        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts);
+        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts, opts.splitComponents);
         reportOpen(openParts);
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/src/mesh_check.cpp

@@ -257,16 +257,40 @@ template <typename M>
 std::vector<Vert> weldMap(const M& m, size_t& welded) {
     const size_t stride = m.numProp ? m.numProp : 3;
     const size_t n = stride ? m.vertProperties.size() / stride : 0;
-    std::map<std::tuple<long long, long long, long long>, Vert> first;
     std::vector<Vert> remap(n);
     welded = 0;
+
+    // Grid key plus the vertex it came from, sorted so that equal positions
+    // land in a run. This was a std::map keyed by the tuple -- one tree node
+    // per VERTEX, ~885,000 of them for a 295K-triangle import -- and sorting
+    // gets the same answer with one allocation. Sorting by (key, vertex)
+    // puts the LOWEST-numbered vertex first in its run, which is the one
+    // emplace() kept as the representative, so the remap is unchanged.
+    struct Keyed {
+        long long x, y, z;
+        Vert v;
+        bool operator<(const Keyed& o) const {
+            if (x != o.x) return x < o.x;
+            if (y != o.y) return y < o.y;
+            if (z != o.z) return z < o.z;
+            return v < o.v;
+        }
+        bool samePos(const Keyed& o) const { return x == o.x && y == o.y && z == o.z; }
+    };
+    std::vector<Keyed> keyed;
+    keyed.reserve(n);
     for (size_t v = 0; v < n; ++v) {
         double p[3];
         pos(m, static_cast<Vert>(v), p);
-        auto key = std::make_tuple(llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6));
-        auto [it, fresh] = first.emplace(key, static_cast<Vert>(v));
-        remap[v] = it->second;
-        if (!fresh) ++welded;
+        keyed.push_back({llround(p[0] * 1e6), llround(p[1] * 1e6), llround(p[2] * 1e6), static_cast<Vert>(v)});
+    }
+    std::sort(keyed.begin(), keyed.end());
+    for (size_t i = 0; i < keyed.size();) {
+        size_t j = i + 1;
+        while (j < keyed.size() && keyed[j].samePos(keyed[i])) ++j;
+        for (size_t k = i; k < j; ++k) remap[keyed[k].v] = keyed[i].v;
+        welded += j - i - 1;
+        i = j;
     }
     return remap;
 }
@@ -274,17 +298,28 @@ std::vector<Vert> weldMap(const M& m, size_t& welded) {
 // Boundary loops, as ordered vertex rings. Each boundary edge belongs to
 // exactly one, so following them from any start returns to it.
 std::vector<std::vector<Vert>> boundaryLoops(const std::vector<std::array<Vert, 3>>& tris) {
-    std::map<Edge, int> count;
-    std::multimap<Vert, Vert> next;      // directed, along the boundary
+    // Every edge, sorted, so "used exactly once" is a run of length one --
+    // the same answer the std::map<Edge,int> gave, without a tree node per
+    // edge. `next` stays a multimap: boundary edges are a handful even on a
+    // badly broken mesh, and it is erased from while being traversed.
+    std::vector<uint64_t> edges;
+    edges.reserve(tris.size() * 3);
     for (const auto& t : tris) {
-        for (int i = 0; i < 3; ++i) ++count[undirected(t[i], t[(i + 1) % 3])];
+        for (int i = 0; i < 3; ++i) edges.push_back(edgeKey(undirected(t[i], t[(i + 1) % 3])));
     }
+    std::sort(edges.begin(), edges.end());
+    const auto usedOnce = [&edges](uint64_t key) {
+        const auto lo = std::lower_bound(edges.begin(), edges.end(), key);
+        return lo != edges.end() && *lo == key && (lo + 1 == edges.end() || *(lo + 1) != key);
+    };
+
+    std::multimap<Vert, Vert> next;      // directed, along the boundary
     for (const auto& t : tris) {
         for (int i = 0; i < 3; ++i) {
             const Vert a = t[i], b = t[(i + 1) % 3];
             // A boundary edge is walked backwards to close the hole: the
             // filling faces must wind against the face that owns the edge.
-            if (count[undirected(a, b)] == 1) next.emplace(b, a);
+            if (usedOnce(edgeKey(undirected(a, b)))) next.emplace(b, a);
         }
     }
     std::vector<std::vector<Vert>> loops;
@@ -320,25 +355,45 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     const std::vector<Vert> remap = weldMap(mesh, welded);
     report.weldedVertices = welded;
 
-    std::vector<std::array<Vert, 3>> tris;
-    std::set<std::array<Vert, 3>> seen;
-    for (size_t t = 0; t < triCount(mesh); ++t) {
+    // Remap every face, then find the duplicates by sorting rather than by
+    // inserting each into a std::set -- one tree node per face otherwise.
+    // "First occurrence wins" survives because the sort carries the face
+    // index and every later member of a run is what gets marked.
+    const size_t nTris = triCount(mesh);
+    std::vector<std::array<Vert, 3>> remapped(nTris);
+    std::vector<char> isDegenerate(nTris, 0), isDuplicate(nTris, 0);
+    std::vector<std::pair<std::array<Vert, 3>, size_t>> byShape;
+    byShape.reserve(nTris);
+    for (size_t t = 0; t < nTris; ++t) {
         Vert v[3];
         triVerts(mesh, t, v);
         std::array<Vert, 3> f{remap[v[0]], remap[v[1]], remap[v[2]]};
+        remapped[t] = f;
         // 2. Degenerate faces, now that welding has collapsed slivers into
         //    repeated indices.
         if (f[0] == f[1] || f[1] == f[2] || f[0] == f[2]) {
-            ++report.droppedDegenerate;
+            isDegenerate[t] = 1;
             continue;
         }
         std::array<Vert, 3> sorted = f;
         std::sort(sorted.begin(), sorted.end());
-        if (!seen.insert(sorted).second) {
+        byShape.emplace_back(sorted, t);
+    }
+    std::sort(byShape.begin(), byShape.end());
+    for (size_t i = 1; i < byShape.size(); ++i) {
+        if (byShape[i].first == byShape[i - 1].first) isDuplicate[byShape[i].second] = 1;
+    }
+
+    std::vector<std::array<Vert, 3>> tris;
+    tris.reserve(nTris);
+    for (size_t t = 0; t < nTris; ++t) {
+        if (isDegenerate[t]) {
+            ++report.droppedDegenerate;
+        } else if (isDuplicate[t]) {
             ++report.droppedDuplicate;
-            continue;
+        } else {
+            tris.push_back(remapped[t]);
         }
-        tris.push_back(f);
     }
 
     std::vector<size_t> component;
@@ -349,12 +404,19 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     //    Before filling, so the new faces are wound against a settled
     //    surface rather than a mixed one.
     {
-        std::map<Edge, std::vector<size_t>> edgeTris;
+        // Every edge really is needed here (the flood fill walks all of
+        // them), so unlike stripSlivers' index this cannot be narrowed --
+        // but it can stop allocating a tree node per edge. Sorted flat, then
+        // searched by equal_range. Faces still come back in ascending index
+        // order within an edge, which the fill's traversal order depends on.
+        std::vector<std::pair<uint64_t, size_t>> edgeTris;
+        edgeTris.reserve(tris.size() * 3);
         for (size_t i = 0; i < tris.size(); ++i) {
             for (int e = 0; e < 3; ++e) {
-                edgeTris[undirected(tris[i][e], tris[i][(e + 1) % 3])].push_back(i);
+                edgeTris.emplace_back(edgeKey(undirected(tris[i][e], tris[i][(e + 1) % 3])), i);
             }
         }
+        std::sort(edgeTris.begin(), edgeTris.end());
         component.assign(tris.size(), SIZE_MAX);
         std::vector<char> done(tris.size(), 0);
         for (size_t seed = 0; seed < tris.size(); ++seed) {
@@ -368,7 +430,11 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
                 stack.pop_back();
                 for (int e = 0; e < 3; ++e) {
                     const Vert a = tris[i][e], b = tris[i][(e + 1) % 3];
-                    for (size_t j : edgeTris[undirected(a, b)]) {
+                    const uint64_t key = edgeKey(undirected(a, b));
+                    const auto lo = std::lower_bound(edgeTris.begin(), edgeTris.end(),
+                                                      std::make_pair(key, size_t{0}));
+                    for (auto it = lo; it != edgeTris.end() && it->first == key; ++it) {
+                        const size_t j = it->second;
                         if (j == i || done[j]) continue;
                         bool sameDir = false;
                         for (int f = 0; f < 3; ++f) {
@@ -427,22 +493,27 @@ M repairMesh(const M& mesh, MeshRepairReport& report) {
     // component that was turned inside out and then back reports nothing,
     // which is what the user sees.
     {
-        std::set<std::array<Vert, 3>> before;
-        for (size_t t = 0; t < triCount(mesh); ++t) {
-            Vert v[3];
-            triVerts(mesh, t, v);
-            before.insert({remap[v[0]], remap[v[1]], remap[v[2]]});
-        }
         auto rotated = [](std::array<Vert, 3> f) {
             // Winding is defined up to rotation, so compare canonically.
             if (f[1] < f[0] && f[1] <= f[2]) return std::array<Vert, 3>{f[1], f[2], f[0]};
             if (f[2] < f[0] && f[2] <= f[1]) return std::array<Vert, 3>{f[2], f[0], f[1]};
             return f;
         };
-        std::set<std::array<Vert, 3>> canon;
-        for (const auto& f : before) canon.insert(rotated(f));
+        // Was two std::sets over every face -- the incoming windings and
+        // their canonical rotations. One sorted, deduplicated vector answers
+        // the same membership questions with no node allocations. Built from
+        // `remapped`, which is every ORIGINAL face including the degenerate
+        // ones the set also held.
+        std::vector<std::array<Vert, 3>> canon;
+        canon.reserve(remapped.size());
+        for (const auto& f : remapped) canon.push_back(rotated(f));
+        std::sort(canon.begin(), canon.end());
+        canon.erase(std::unique(canon.begin(), canon.end()), canon.end());
+        const auto known = [&canon](const std::array<Vert, 3>& f) {
+            return std::binary_search(canon.begin(), canon.end(), f);
+        };
         for (const auto& f : tris) {
-            if (!canon.count(rotated(f)) && canon.count(rotated({f[0], f[2], f[1]}))) {
+            if (!known(rotated(f)) && known(rotated({f[0], f[2], f[1]}))) {
                 ++report.reversedFaces;
             }
         }

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/tests/test_bytecode_compiler.cpp

@@ -2159,3 +2159,35 @@ TEST(BytecodeCompiler, CompileTimeArgumentPlanMatchesTheNameMatchingRules) {
                                "echo(count(100));"),
               "ECHO: 5050");
 }
+
+// A declaration may repeat a parameter name. BOSL2's regular_prism() declares
+// both `length` and `height` twice, and three of its own documentation
+// examples stopped rendering when the compile-time argument plan bound only
+// the first of them -- the body read undef from whichever slot the repeated
+// name finally resolved to, and asserted. The name-matching path this
+// replaced filled every parameter of that name, because it walked the
+// PARAMETERS asking which argument matched, not the other way round.
+TEST(BytecodeCompiler, ARepeatedParameterNameIsBoundEveryTimeItAppears) {
+    const std::string f = "function f(a, height, b, height) = str(a, \"/\", height, \"/\", b);\n";
+    const std::string g = "function g(height, b, height) = str(height, \"/\", b);\n";
+
+    for (const auto& [src, call] : std::vector<std::pair<std::string, std::string>>{
+             {f, "f(a = 1, height = 20, b = 2)"},   // named
+             {f, "f(1, 20, 2)"},                    // positional landing on the first copy
+             {g, "g(20, 2)"},                       // repeated name in first position
+             {f, "f(a = 1, b = 2, height = 20)"},   // named, out of order
+         }) {
+        std::string compiled, interpreted;
+        {
+            ScopedVm on(true);
+            compiled = runCapturingEcho(src + "echo(" + call + ");");
+        }
+        {
+            ScopedVm off(false);
+            interpreted = runCapturingEcho(src + "echo(" + call + ");");
+        }
+        EXPECT_EQ(compiled, interpreted) << "VM and interpreter disagree for: " << call;
+        EXPECT_NE(compiled.find("20"), std::string::npos)
+            << call << " lost its repeated-name argument: " << compiled;
+    }
+}

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/tests/test_export.cpp

@@ -163,10 +163,16 @@ TEST(ExportAmf, WritesOneObjectAndOneMaterialPerColour) {
 }
 
 TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
+    // splitComponents, because two objects is the premise: same-coloured
+    // disjoint pieces are ONE object by default (see the DisjointPieces
+    // tests below). What is under test here is that the two of them share a
+    // single material entry rather than each declaring their own.
     std::vector<ColoredBody> bodies =
         evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"red\") cube(2);");
     const std::string path = tempPath("shared.amf").string();
-    exportModel(path, bodies, ExportOptions{});
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
 
     const std::string xml = readFile(path);
     EXPECT_EQ(countOf(xml, "<object id="), 2u);
@@ -174,6 +180,50 @@ TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
     std::remove(path.c_str());
 }
 
+// Issue #319: a model in several disconnected pieces was written as one
+// object PER PIECE, so a slicer listed them individually -- hundreds of
+// entries for a multiboard tile, and Prusa Slicer objecting. OpenSCAD writes
+// one object, and so does this by default now; the split is still available
+// for callers that want the pieces apart.
+TEST(ExportSplit, DisjointPiecesAreOneObjectByDefault) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("joined.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 1u);
+    EXPECT_EQ(countOf(xml, "<volume"), 1u);
+    std::remove(path.c_str());
+}
+
+TEST(ExportSplit, DisjointPiecesSplitWhenAsked) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);");
+    const std::string path = tempPath("split.amf").string();
+    ExportOptions opts;
+    opts.splitComponents = true;
+    exportModel(path, bodies, opts);
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 3u);
+    std::remove(path.c_str());
+}
+
+// Rule 2 is not what became optional: differently-coloured solids must stay
+// separate objects either way, or a multi-material export loses its colours.
+TEST(ExportSplit, ColoursStayApartWithTheSplitOff) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(10); translate([20,0,0]) color(\"blue\") cube(10);");
+    const std::string path = tempPath("colours.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    std::remove(path.c_str());
+}
+
 TEST(ExportAmf, MaterialAndObjectIdsStartAtOne) {
     // id 0 is reserved by the spec; a reader may drop anything using it.
     std::vector<ColoredBody> bodies = evalToBodies("cube(2);");

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/tests/test_mesh_check.cpp

@@ -358,6 +358,33 @@ TEST(SliverStrip, ANeedleIsRemovedWithoutSplittingAnything) {
     EXPECT_TRUE(d.manifold()) << d.summary();
 }
 
+// Three copies of one position is TWO welds, not one, and the survivor is the
+// lowest-numbered of them. Both facts used to fall out of inserting into a
+// std::map and keeping whatever was already there; they now come from run
+// lengths in a sorted list, where an off-by-one or a wrong representative
+// would be silent -- the geometry is identical either way, only the indices
+// differ.
+TEST(MeshCheck, ThreeCoincidentVerticesAreTwoWeldsOntoTheLowestIndex) {
+    manifold::MeshGL m = tetra();
+    const uint32_t a = 4, b = 5;
+    m.vertProperties.insert(m.vertProperties.end(), {0, 0, 0});   // == vertex 0
+    m.vertProperties.insert(m.vertProperties.end(), {0, 0, 0});   // == vertex 0 again
+    bool usedA = false;
+    for (size_t i = 0; i < m.triVerts.size(); ++i) {
+        if (m.triVerts[i] != 0 || i < 6) continue;
+        m.triVerts[i] = usedA ? b : a;                            // spread over both copies
+        usedA = !usedA;
+    }
+
+    MeshRepairReport r;
+    const manifold::MeshGL fixed = repairMesh(m, r);
+    EXPECT_EQ(r.weldedVertices, 2u) << r.summary();
+    for (uint32_t v : fixed.triVerts) {
+        EXPECT_NE(v, a) << "welded away, so no face may still name it";
+        EXPECT_NE(v, b) << "welded away, so no face may still name it";
+    }
+}
+
 // import(repair=true) goes through repairMesh, so it has to deal with
 // slivers too -- an imported STL is exactly where they turn up.
 TEST(MeshRepair, StripsSliversAndRestitchesThem) {

{openscad_cpp_evaluator-1.7.0 → openscad_cpp_evaluator-1.8.0}/tests/test_python_bindings.py

@@ -633,3 +633,29 @@ def test_degenerate_ranges_do_not_overflow_the_element_count(tmp_path):
     # Silent for NaN; the unbounded pair warn, with the reference's number.
     assert len(warnings) == 2, warnings
     assert all("too many elements (4294967295)" in w for w in warnings), warnings
+
+
+def test_export_model_facade_accepts_split_components(tmp_path):
+    """The Python facade's signature must track the nanobind binding's.
+
+    They are two hand-written parameter lists for one call, and adding
+    `split_components` to the binding alone left the facade dropping it --
+    a TypeError the C++ suite cannot see, because it never goes through
+    Python. Caught in practice, hence this.
+    """
+    from openscad_cpp_evaluator import Evaluator, export_model
+
+    src = tmp_path / "pieces.scad"
+    src.write_text("cube(10); translate([20,0,0]) cube(10); translate([40,0,0]) cube(10);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    def objects_in(path, **kwargs):
+        export_model(str(path), ev.geometry, **kwargs)
+        import zipfile
+        with zipfile.ZipFile(path) as z:
+            return z.read("3D/3dmodel.model").decode().count("<object ")
+
+    # Default matches OpenSCAD: one object however many pieces.
+    assert objects_in(tmp_path / "joined.3mf") == 1
+    assert objects_in(tmp_path / "split.3mf", split_components=True) == 3