openscad-cpp-evaluator 1.50.2__tar.gz → 1.51.0__tar.gz

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/CLAUDE.md

@@ -2012,3 +2012,28 @@ warning). A non-positive or non-numeric `alpha`/`offset` warns and leaves the ch
   faces). Time follows OUTPUT size. Not done: CGAL's manifold post-pass for very thin features
   (no failure seen yet), and the same input scaled can differ by a near-tie or two (same shape,
   volume within 0.2%), which is why `DefaultsScaleWithTheModel` compares within tolerances.
+
+## `export_as()`
+
+`export_as("name") { ... }` names its children's geometry as one object in a file that holds several
+(BelfrySCAD #918; `supported_feature("export-as")` is 1). In 3MF it is the `<object name="...">`
+attribute, in OBJ the `o` line (whitespace becomes `_`), in AMF `<metadata type="name">`; the other
+formats have no object names and ignore it. Geometry outside any `export_as()` is named as before.
+
+- **The name rides on the body** (`ColoredBody::exportName`), so everything that copies its
+  children's bodies carries it: transforms, `color()`, the modifiers, `render()`, `profile_time()`,
+  user modules. An op that **builds** a new body (any boolean, hull, extrude, ...) drops it, and
+  `checkExportNames` warns about an `export_as()` inside one, read off the resolved tree so a
+  ManifoldCache hit warns the same. An inner `export_as()` keeps its name; the outer one names only
+  what is still unnamed.
+- **Export** (`splitBodiesForExport`): the name is part of the object key, so a named part is its own
+  object whatever the colour options say, and two touching same-coloured parts no longer weld. With
+  colours split, colour still keys inside a name. A named part is **always** split into its connected
+  pieces, whatever `splitComponents` says, and a name that ends up as several objects (pieces,
+  colours, an open shell beside a solid) is numbered `name_1`, `name_2`, ... so every object stays
+  told apart. The same name on two `export_as()` calls warns and merges them into one part, so
+  touching uses weld and disjoint ones are numbered pieces.
+- A missing or empty name warns and leaves the children unnamed. Not upstream: OpenSCAD has no
+  `export_as()` and drops an unknown module's children, so a portable script guards on
+  `supported_feature("export-as")`.
+- `src/builtins/export_as.cpp`; tests in `tests/test_export_as.cpp`.

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.50.2
+Version: 1.51.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT AND OFL-1.1

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -8,6 +8,7 @@
 #include <array>
 #include <memory>
 #include <optional>
+#include <string>
 #include <vector>
 
 namespace oscadeval {
@@ -92,6 +93,10 @@ struct ColoredBody {
     manifold::mat3x4 sectionXform{manifold::vec3(1, 0, 0), manifold::vec3(0, 1, 0),
                                    manifold::vec3(0, 0, 1), manifold::vec3(0, 0, 0)};
     BodyRole role = BodyRole::Normal;
+    // The name export_as() gave this body: the object it becomes in a file
+    // that holds several (splitBodiesForExport). Copied along by everything
+    // that copies the body; an op that builds a new body drops it.
+    std::optional<std::string> exportName;
     std::optional<std::vector<std::array<float, 4>>> triColors; // per-triangle RGBA, multi-color CSG merges only
 
     // The operands a union() merged into this body, kept unmerged, each as

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -620,6 +620,12 @@ public:
     // definition for why this cannot be done by tagging bodies.
     void rerootAtShowOnly(std::vector<std::unique_ptr<CSGNode>>& tree);
 
+    // Warns about an export_as() whose name cannot reach the file: one
+    // inside an operation that merges it with its siblings, or a name used
+    // by more than one export_as(). Read off the resolved tree, so a
+    // ManifoldCache hit says the same as a fresh build. See export_as.cpp.
+    void checkExportNames(const std::vector<std::unique_ptr<CSGNode>>& tree);
+
     // parent_module(idx) support: walks the live module-call stack
     // (innermost last) and returns the name `idx` levels up from the
     // current module, or undef if out of range. Public because

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/include/openscad_cpp_evaluator/export.hpp

@@ -22,6 +22,10 @@ struct ExportObject {
     std::vector<uint32_t> tris; // vertex-index triples
     std::array<float, 4> color = kDefaultExportColor;
     std::vector<std::array<float, 4>> triColors;
+    // export_as()'s name, numbered "name_1", "name_2", ... when the part
+    // comes out as several objects. Empty for geometry no export_as()
+    // named; each writer then names it as it always has.
+    std::string name;
 };
 
 // The implicit top-level union, cut into objects that never overlap.

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/CMakeLists.txt

@@ -48,6 +48,7 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/import.cpp
   builtins/topology.cpp
   builtins/alpha_wrap.cpp
+  builtins/export_as.cpp
   ../third_party/predicates/predicates.c
   builtins/extrude.cpp
   builtins/roof.cpp

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/builtins/builtins.hpp

@@ -203,6 +203,11 @@ CSGParams resolveAlphaWrap(Evaluator& ev, const oscad::ModularCall& node, EvalCo
 std::vector<ColoredBody> generateAlphaWrap(Evaluator& ev, const CSGParams& params,
                                            const std::vector<std::unique_ptr<CSGNode>>& children,
                                            const oscad::ASTNode& node);
+// export_as(name) -- names its children's object in an export (export_as.cpp).
+CSGParams resolveExportAs(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+std::vector<ColoredBody> generateExportAs(Evaluator& ev, const CSGParams& params,
+                                          const std::vector<std::unique_ptr<CSGNode>>& children,
+                                          const oscad::ASTNode& node);
 CSGParams resolveSimplify(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params,
                                            const std::vector<std::unique_ptr<CSGNode>>& children,

openscad_cpp_evaluator-1.51.0/src/builtins/export_as.cpp

@@ -0,0 +1,87 @@
+#include "builtins.hpp"
+
+#include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include <map>
+#include <set>
+
+namespace oscadeval {
+
+// export_as("name") { ... } -- names the geometry of its children as one
+// object in a file that holds several (3MF, OBJ, AMF); see
+// splitBodiesForExport. The name rides on ColoredBody::exportName, which
+// every transform, color() and modifier carries along because they copy the
+// body. An inner export_as() keeps its own name: only unnamed bodies take
+// this one.
+CSGParams resolveExportAs(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    CSGParams params;
+    const Value name = getArg(args, 0, "name");
+    const std::string* s = std::get_if<std::string>(&name);
+    if (s && !s->empty()) params["name"] = *s;
+    else ev.warn("export_as() needs a non-empty name string; its children are exported unnamed", &node.position());
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
+    return params;
+}
+
+std::vector<ColoredBody> generateExportAs(Evaluator&, const CSGParams& params,
+                                          const std::vector<std::unique_ptr<CSGNode>>& children,
+                                          const oscad::ASTNode&) {
+    std::vector<ColoredBody> result = flattenCsgTree(children);
+    auto it = params.find("name");
+    if (it == params.end()) return result;
+    const std::string& name = std::get<std::string>(it->second);
+    for (ColoredBody& b : result) {
+        if (!b.exportName) b.exportName = name;
+    }
+    return result;
+}
+
+namespace {
+
+// The builtins whose result is their children's own bodies, copied (so an
+// exportName survives them). Every other builtin builds new bodies from its
+// children and drops the name.
+bool keepsChildBodies(const CSGNode& n) {
+    static const std::set<std::string, std::less<>> kinds = {
+        "translate", "rotate", "scale", "mirror", "multmatrix", "resize", "color", "highlight",
+        "background", "show_only", "render", "profile_time", "export_as", "children",
+    };
+    return !n.isBuiltin || kinds.count(n.kind) > 0;
+}
+
+void walkExportAs(Evaluator& ev, const std::vector<std::unique_ptr<CSGNode>>& nodes, const CSGNode* merger,
+                  std::map<std::string, int>& uses) {
+    for (const std::unique_ptr<CSGNode>& c : nodes) {
+        const CSGNode* childMerger = merger;
+        if (c->isBuiltin && c->kind == "export_as") {
+            auto it = c->params.find("name");
+            if (it != c->params.end() && c->node) {
+                const std::string& name = std::get<std::string>(it->second);
+                if (merger) {
+                    ev.warn("export_as(\"" + name + "\") is inside " + merger->kind + "(), which merges it with " +
+                                "its siblings, so the name is lost",
+                            &c->node->position());
+                } else if (++uses[name] == 2) {
+                    ev.warn("export_as(\"" + name + "\") is used more than once; those parts are merged into one " +
+                                "part named \"" + name + "\"",
+                            &c->node->position());
+                }
+            }
+        } else if (!merger && !keepsChildBodies(*c)) {
+            childMerger = c.get();
+        }
+        walkExportAs(ev, c->children, childMerger, uses);
+    }
+}
+
+} // namespace
+
+void Evaluator::checkExportNames(const std::vector<std::unique_ptr<CSGNode>>& tree) {
+    std::map<std::string, int> uses;
+    walkExportAs(*this, tree, nullptr, uses);
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/builtins/function_builtins.cpp

@@ -1002,6 +1002,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"discretization-by-error", 1.0}, // $fe, always on (upstream: behind --enable)
         {"profile-time", 1.0},       // profile_time(label) { ... } and profile_time(label) expr
         {"alpha-wrap", 1.0},         // alpha_wrap(alpha, offset)
+        {"export-as", 1.0},          // export_as(name) { ... }
     };
     return levels;
 }

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/builtins/registry.cpp

@@ -40,6 +40,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"simplify", &resolveSimplify},
         {"mesh_repair", &resolveMeshRepair},
         {"alpha_wrap", &resolveAlphaWrap},
+        {"export_as", &resolveExportAs},
         {"levelset", &resolveLevelSet},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
@@ -84,6 +85,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"simplify", &generateSimplify},
         {"mesh_repair", &generateMeshRepair},
         {"alpha_wrap", &generateAlphaWrap},
+        {"export_as", &generateExportAs},
         {"levelset", &generateLevelSet},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
@@ -138,6 +140,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"simplify", {"tolerance"}},
         {"mesh_repair", {"tolerance"}},
         {"alpha_wrap", {"alpha", "offset"}},
+        {"export_as", {"name"}},
         {"levelset", {"field", "bounds", "isovalue", "invert", "edge"}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/colored_body.cpp

@@ -62,6 +62,7 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
             flat.section = cb.section;
             flat.sectionXform = cb.sectionXform;
             flat.role = cb.role;
+            flat.exportName = cb.exportName;
             out.push_back(std::move(flat));
         } else {
             out.push_back(cb);

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/csg_resolve.cpp

@@ -293,6 +293,7 @@ std::vector<ColoredBody> Evaluator::evaluateImpl(const NodeList& nodes, EvalCont
     } generateRequestedGuard{generateRequested_};
     std::vector<std::unique_ptr<CSGNode>> tree = resolveTreeImpl(nodes, ctx);
     rerootAtShowOnly(tree);
+    checkExportNames(tree);
     const Clock::time_point resolveEnd = profiling_ ? Clock::now() : Clock::time_point{};
     // generate = false is the resolve-only path: the language has run and
     // the tree is built, so anything the script itself gets wrong has already

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/src/export.cpp

@@ -8,12 +8,14 @@
 #include <manifold/manifold.h>
 
 #include <algorithm>
+#include <cctype>
 #include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <ctime>
 #include <fstream>
 #include <locale>
+#include <map>
 #include <sstream>
 #include <optional>
 #include <stdexcept>
@@ -103,6 +105,21 @@ void writeStl(const std::string& path, const std::vector<ColoredBody>& bodies) {
     }
 }
 
+// An export_as() name as XML attribute or element text.
+static std::string xmlEscape(const std::string& s) {
+    std::string out;
+    for (char c : s) {
+        switch (c) {
+            case '&': out += "&amp;"; break;
+            case '<': out += "&lt;"; break;
+            case '>': out += "&gt;"; break;
+            case '"': out += "&quot;"; break;
+            default: out += c;
+        }
+    }
+    return out;
+}
+
 void writeObj(const std::string& path, const std::vector<ExportObject>& objects) {
     // OBJ carries no colour of its own: `usemtl` names an entry in a .mtl
     // sitting next to the .obj, so an OBJ export writes TWO files. A reader
@@ -140,7 +157,16 @@ void writeObj(const std::string& path, const std::vector<ExportObject>& objects)
     size_t objIndex = 0;
     for (const ExportObject& o : objects) {
         ++objIndex;
-        out << "o object_" << objIndex << "\n";
+        if (o.name.empty()) {
+            out << "o object_" << objIndex << "\n";
+        } else {
+            // An OBJ name runs to the end of the line, and readers split it
+            // at whitespace.
+            std::string name = o.name;
+            for (char& c : name)
+                if (std::isspace(static_cast<unsigned char>(c))) c = '_';
+            out << "o " << name << "\n";
+        }
         const size_t vertCount = o.verts.size() / 3;
         for (size_t v = 0; v < vertCount; ++v) {
             out << "v " << formatG6(o.verts[v * 3]) << " " << formatG6(o.verts[v * 3 + 1]) << " "
@@ -265,7 +291,9 @@ void writeThreeMf(const std::string& path, const std::vector<ExportObject>& obje
         resources += "</m:colorgroup>";
 
         const int objectId = nextId++;
-        resources += "<object id=\"" + std::to_string(objectId) + "\" type=\"model\" pid=\"" +
+        resources += "<object id=\"" + std::to_string(objectId) + "\" type=\"model\"";
+        if (!o.name.empty()) resources += " name=\"" + xmlEscape(o.name) + "\"";
+        resources += " pid=\"" +
                      std::to_string(colorGroupId) + "\" pindex=\"0\"><mesh><vertices>";
         const size_t vertCount = o.verts.size() / 3;
         for (size_t v = 0; v < vertCount; ++v) {
@@ -374,13 +402,21 @@ bool boxesOverlap(const manifold::Box& ba, const manifold::Box& bb) {
 // A colour key that keeps per-triangle-coloured bodies apart from
 // everything, including each other. Their colours index their own triangle
 // list, and a union would rewrite that list and lose them.
+//
+// An export_as() name keys too: a named part is its own object whatever
+// the colour options say. With colours not split (`byColor` false), the
+// name is all that keys.
 struct ColorKey {
     bool perTriangle = false;
     size_t index = 0; // position in `solids`, for the per-triangle case
     bool hasColor = false;
     std::array<float, 4> color{};
+    std::optional<std::string> name;
+    bool byColor = true;
 
     bool operator==(const ColorKey& o) const {
+        if (name != o.name) return false;
+        if (!byColor) return true;
         if (perTriangle != o.perTriangle) return false;
         if (perTriangle) return index == o.index;
         if (hasColor != o.hasColor) return false;
@@ -476,6 +512,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
         std::optional<std::array<float, 4>> color;
         std::vector<std::array<float, 4>> triColors;
         std::vector<uint32_t> tris;
+        std::optional<std::string> name;
     };
 
     std::vector<Solid> solids;
@@ -503,6 +540,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             if (obj.tris.empty()) continue;
             obj.color = cb.color.value_or(kDefaultExportColor);
             if (cb.triColors) obj.triColors = resolveThemeColors(*cb.triColors);
+            obj.name = cb.exportName.value_or("");
             loose.push_back(std::move(obj));
             if (openParts) openParts->push_back(index);
             continue;
@@ -511,6 +549,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
         Solid s;
         s.man = *cb.body;
         s.color = cb.color;
+        s.name = cb.exportName;
         if (cb.triColors) s.triColors = resolveThemeColors(*cb.triColors);
         s.tris = s.man.GetMeshGL().triVerts;
         if (s.tris.empty()) continue;
@@ -527,6 +566,8 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             k.index = i;
             k.hasColor = solids[i].color.has_value();
             if (k.hasColor) k.color = *solids[i].color;
+            k.name = solids[i].name;
+            k.byColor = splitColors;
             keys.push_back(k);
         }
         // Splitting by colour is for a MULTI-MATERIAL print, where each
@@ -536,7 +577,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
         // separate walls. Unioning everything here (rather than
         // concatenating the per-colour objects afterwards) is what makes
         // touching regions weld instead of leaving coincident faces.
-        const bool allSame = !splitColors ||
+        const bool allSame =
             std::all_of(keys.begin(), keys.end(), [&](const ColorKey& k) { return k == keys[0]; });
 
         if (allSame) {
@@ -597,7 +638,7 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
                 Claimed c;
                 c.man = std::move(piece);
                 c.color = s.color;
-                c.triColors = s.triColors;
+                if (splitColors) c.triColors = s.triColors;
                 c.sourceTris = s.tris;
                 c.key = keys[n];
                 owned.push_back(std::move(c));
@@ -623,10 +664,12 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
     for (const Claimed& g : claimedGroups) {
         // 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.
+        // in, which is what OpenSCAD writes. A named part always splits: its
+        // pieces are numbered below, so they stay one part by name. 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 (splitComponents || g.key.name) parts = g.man.Decompose();
         if (parts.empty()) parts.push_back(g.man);
         for (const manifold::Manifold& part : parts) {
             if (part.IsEmpty()) continue;
@@ -635,10 +678,20 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             if (obj.tris.empty()) continue;
             obj.color = g.color.value_or(kDefaultExportColor);
             obj.triColors = carryTriColors(g.triColors, g.sourceTris, obj.tris);
+            obj.name = g.key.name.value_or("");
             out.push_back(std::move(obj));
         }
     }
     out.insert(out.end(), std::make_move_iterator(loose.begin()), std::make_move_iterator(loose.end()));
+
+    // A name that came out as several objects -- disconnected pieces,
+    // colours, an open shell beside a solid -- is numbered, so every object
+    // in the file is still told apart by name.
+    std::map<std::string, int> total, seen;
+    for (const ExportObject& o : out)
+        if (!o.name.empty()) ++total[o.name];
+    for (ExportObject& o : out)
+        if (!o.name.empty() && total[o.name] > 1) o.name += "_" + std::to_string(++seen[o.name]);
     return out;
 }
 
@@ -924,7 +977,9 @@ void writeAmf(const std::string& path, const std::vector<ExportObject>& objects)
     }
     for (size_t oi = 0; oi < objects.size(); ++oi) {
         const ExportObject& o = objects[oi];
-        out << "  <object id=\"" << (oi + 1) << "\">\n    <mesh>\n      <vertices>\n";
+        out << "  <object id=\"" << (oi + 1) << "\">\n";
+        if (!o.name.empty()) out << "    <metadata type=\"name\">" << xmlEscape(o.name) << "</metadata>\n";
+        out << "    <mesh>\n      <vertices>\n";
         for (size_t v = 0; v < o.verts.size() / 3; ++v) {
             out << "        <vertex><coordinates><x>" << formatG6(o.verts[v * 3]) << "</x><y>"
                 << formatG6(o.verts[v * 3 + 1]) << "</y><z>" << formatG6(o.verts[v * 3 + 2])

{openscad_cpp_evaluator-1.50.2 → openscad_cpp_evaluator-1.51.0}/tests/CMakeLists.txt

@@ -46,6 +46,7 @@ add_executable(oscad_eval_tests
   test_viewport_params.cpp
   test_unexpected_args.cpp
   test_alpha_wrap.cpp
+  test_export_as.cpp
   test_cli.cpp
 )
 # oscad_cli_lib PUBLIC-links openscad_cpp_evaluator, so naming it here too

openscad_cpp_evaluator-1.51.0/tests/test_export_as.cpp

@@ -0,0 +1,108 @@
+#include "openscad_cpp_evaluator/export.hpp"
+
+#include "test_helpers.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <gtest/gtest.h>
+#include <sstream>
+
+using namespace oscadeval;
+using namespace oscadeval::test;
+
+namespace {
+
+std::vector<std::string> namesOf(const std::vector<ExportObject>& objs) {
+    std::vector<std::string> out;
+    for (const ExportObject& o : objs) out.push_back(o.name);
+    return out;
+}
+
+std::vector<std::string> split(const std::string& code, bool components = false, bool colors = true) {
+    Evaluated e = evaluateSrc(code);
+    return namesOf(splitBodiesForExport(e.bodies, nullptr, components, colors));
+}
+
+std::vector<std::string> warningsOf(const std::string& code) {
+    std::vector<std::string> log;
+    evaluateSrc(code, [&](const std::string& m) { log.push_back(m); });
+    return log;
+}
+
+std::string slurp(const std::filesystem::path& p) {
+    std::ifstream in(p);
+    std::stringstream ss;
+    ss << in.rdbuf();
+    return ss.str();
+}
+
+} // namespace
+
+TEST(ExportAs, TouchingNamedPartsStaySeparate) {
+    // Same colour, sharing a face: without names these weld into one object.
+    EXPECT_EQ(split(R"(export_as("jar") cube(10); export_as("lid") translate([10,0,0]) cube(10);)"),
+              (std::vector<std::string>{"jar", "lid"}));
+}
+
+TEST(ExportAs, NameSurvivesTransformsAndColor) {
+    EXPECT_EQ(split(R"(translate([5,0,0]) color("red") export_as("jar") rotate(10) cube(10);)"),
+              (std::vector<std::string>{"jar"}));
+}
+
+TEST(ExportAs, UnnamedGeometryKeepsAutomaticNaming) {
+    EXPECT_EQ(split(R"(export_as("jar") cube(10); translate([20,0,0]) cube(10);)"),
+              (std::vector<std::string>{"jar", ""}));
+}
+
+TEST(ExportAs, NamedPartIsOneObjectEvenWithColorsNotSplit) {
+    EXPECT_EQ(split(R"(export_as("jar") cube(10); export_as("lid") translate([10,0,0]) cube(10);)", false, false),
+              (std::vector<std::string>{"jar", "lid"}));
+}
+
+TEST(ExportAs, PiecesOfOnePartAreNumbered) {
+    const std::string code = R"(export_as("leg") { cube(1); translate([5,0,0]) cube(1); })";
+    // Whatever the components option says: a named part always splits.
+    EXPECT_EQ(split(code), (std::vector<std::string>{"leg_1", "leg_2"}));
+    EXPECT_EQ(split(code, /*components=*/true), (std::vector<std::string>{"leg_1", "leg_2"}));
+    EXPECT_EQ(split(R"(export_as("leg") cube(1);)"), (std::vector<std::string>{"leg"}));
+}
+
+TEST(ExportAs, InnerNameWins) {
+    EXPECT_EQ(split(R"(export_as("kit") { export_as("jar") cube(1); translate([5,0,0]) cube(1); })"),
+              (std::vector<std::string>{"jar", "kit"}));
+}
+
+TEST(ExportAs, NameInsideAMergingOperationWarns) {
+    const auto log = warningsOf(R"(union() { export_as("jar") cube(1); cube(2); })");
+    EXPECT_TRUE(anyContains(log, "export_as(\"jar\") is inside union()"));
+    // Through a user module too: the module is not the merger, union() is.
+    EXPECT_TRUE(anyContains(warningsOf(R"(module m() export_as("a") cube(1); difference() { m(); cube(0.5); })"),
+                            "export_as(\"a\") is inside difference()"));
+}
+
+TEST(ExportAs, DuplicateNameWarnsAndMerges) {
+    const std::string code = R"(export_as("jar") cube(1); export_as("jar") translate([5,0,0]) cube(1);)";
+    EXPECT_TRUE(anyContains(warningsOf(code), "export_as(\"jar\") is used more than once"));
+    // One name, two disjoint pieces: numbered.
+    EXPECT_EQ(split(code), (std::vector<std::string>{"jar_1", "jar_2"}));
+}
+
+TEST(ExportAs, MissingNameWarns) {
+    EXPECT_TRUE(anyContains(warningsOf("export_as() cube(1);"), "export_as() needs a non-empty name string"));
+    EXPECT_EQ(split("export_as() cube(1);"), (std::vector<std::string>{""}));
+}
+
+TEST(ExportAs, WritersCarryTheName) {
+    Evaluated e = evaluateSrc(R"(export_as("big jar") cube(10); export_as("a&b") translate([20,0,0]) cube(1);)");
+    const auto dir = std::filesystem::temp_directory_path();
+    exportModel((dir / "oscad_eval_test_export_as.obj").string(), e.bodies);
+    const std::string obj = slurp(dir / "oscad_eval_test_export_as.obj");
+    EXPECT_NE(obj.find("o big_jar\n"), std::string::npos);
+    exportModel((dir / "oscad_eval_test_export_as.amf").string(), e.bodies);
+    const std::string amf = slurp(dir / "oscad_eval_test_export_as.amf");
+    EXPECT_NE(amf.find("<metadata type=\"name\">a&amp;b</metadata>"), std::string::npos);
+}
+
+TEST(ExportAs, FeatureIsAdvertised) {
+    EXPECT_TRUE(anyContains(warningsOf(R"(echo(supported_feature("export-as"));)"), "ECHO: 1"));
+}