openscad-cpp-evaluator 1.38.1__tar.gz → 1.40.0__tar.gz

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/booleans.cpp

@@ -231,7 +231,8 @@ manifold::Manifold finishKeepMinuend(Evaluator& ev, std::vector<KeepPart>& parts
     std::optional<manifold::Manifold> out;
     for (KeepPart& part : parts) {
         if (!part.body.body) continue;
-        manifold::MeshGL mesh = part.body.body->GetMeshGL();
+        // MeshGL64: rebuilt below, and float32 would move every vertex.
+        manifold::MeshGL64 mesh = part.body.body->GetMeshGL64();
         if (mesh.triVerts.empty()) continue;
         std::unordered_map<uint32_t, uint32_t> remap;
         for (uint32_t& id : mesh.runOriginalID) {

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/builtins.hpp

@@ -268,6 +268,14 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
 
 // text() -- text.cpp.
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+
+// The font size text()/textmetrics()/fontmetrics() draw at: `size`
+// (default 10), or `em` * 72/100 when `em` is given -- upstream's
+// correction for the 100/72 factor that makes `size` the cap height
+// rather than the em square (openscad #4304). `size` given alongside
+// `em` is ignored, with upstream's warning naming `caller`.
+double textSizeArg(Evaluator& ev, const CallArgs& args, std::optional<int> sizePos, std::optional<int> emPos,
+                   const char* caller, const oscad::Position* where);
 std::vector<ColoredBody> generateText(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/function_builtins.cpp

@@ -776,7 +776,7 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 }
 
 // textmetrics(text=, size=10, font=, direction=, language=, script=,
-// halign=, valign=, spacing=) -- measures `text` against the
+// halign=, valign=, spacing=, em=) -- measures `text` against the
 // FontProvider-resolved font, laid out by exactly the same shaping call
 // text() makes, and returns an OscObject with position/size/ascent/
 // descent/offset/advance in real OpenSCAD's key order. Going through the
@@ -784,10 +784,10 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 // a script positions against cannot disagree with what it draws.
 Value builtinTextmetrics(Evaluator& ev, const CallArgs& args, const oscad::Position* pos) {
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
-    const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
+    const double size = textSizeArg(ev, args, 1, 9, "textmetrics", pos);
     // Positional indices, all of them: OpenSCAD's own signature is
     // textmetrics(text, size, font, direction, language, script, halign,
-    // valign, spacing) and it honours every one of those positionally --
+    // valign, spacing, em) and it honours every one of those positionally --
     // verified against the 2026.02.01 binary, not read off a doc page.
     // `font` being name-only here is what made
     // `textmetrics("Hi", 10, "Liberation Sans:style=Bold")` silently
@@ -817,10 +817,10 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args, const oscad::Posit
     });
 }
 
-// fontmetrics(size=10, font=) -- global metrics of the FontProvider-
+// fontmetrics(size=10, font=, em=) -- global metrics of the FontProvider-
 // resolved font, scaled for `size`. Mirrors _builtin_fontmetrics.
-Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
-    const double size = toDoubleLenient(getArg(args, 0, "size", Value{10.0}));
+Value builtinFontmetrics(Evaluator& ev, const CallArgs& args, const oscad::Position* pos) {
+    const double size = textSizeArg(ev, args, 0, 2, "fontmetrics", pos);
     // Positional too: fontmetrics(10, "Liberation Sans:style=Bold") is
     // how the bug report was written, and how the real binary reads it.
     const std::string fontSpec = asStringOr(getArg(args, 1, "font", Value{std::string("")}), "");
@@ -1255,7 +1255,7 @@ Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vect
     switch (id) {
         case BuiltinFnId::None: return Value{}; // unreachable: handled above
         case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args, &node.position());
-        case BuiltinFnId::FontMetrics: return builtinFontmetrics(ev, args);
+        case BuiltinFnId::FontMetrics: return builtinFontmetrics(ev, args, &node.position());
         case BuiltinFnId::Abs: return Value{std::fabs(toDoubleLenient(getArg(args, 0, "x", Value{})))};
         case BuiltinFnId::Sign: {
             const double x = toDoubleLenient(getArg(args, 0, "x", Value{}));

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/primitives_3d.cpp

@@ -275,6 +275,121 @@ SphereMesh buildAligned(double r, int hsides, int vsides, bool stagger) {
     return m;
 }
 
+// "octa": an octahedron with each face cut into an n x n triangular grid,
+// n = ceil(segments / 4), pushed out to the sphere -- 4n^2 + 2 vertices,
+// one on each pole of all three axes. Vertex placement is upstream
+// OpenSCAD's (primitives.cc, SphereNode::createGeometryOcta): an interior
+// vertex is where the great-circle arcs through equally spaced edge points
+// meet, the three pairwise intersections averaged.
+//
+// The mesh is EXACTLY symmetric under all 48 symmetries of the octahedron,
+// not merely to rounding: every vertex is computed once, for its
+// barycentric weights sorted largest first, and the other copies are that
+// one point with its coordinates permuted and negated, which is exact.
+// Within a rounding error is not good enough. Manifold::Sphere, which this
+// used to be, is symmetric only to ~1e-15, so a copy rotated 90 degrees
+// landed a hair off the original and difference() of the two left a mass of
+// sliver shards where it should leave nothing.
+//
+// ponytail: the great-circle vertices are not bit-identical to circle()'s
+// (Manifold's Circle reduces angles by quadrant, not octant, so it is not
+// exactly symmetric itself); a sphere and a coaxial circle of the same $fn
+// agree to rounding only.
+namespace {
+// (cos, sin) of (90 * m / n) degrees, always computed from the angle at or
+// below 45 degrees, so the points at m and n - m are exact mirrors.
+std::array<double, 2> quarterArc(int m, int n) {
+    if (2 * m == n) return {std::sqrt(0.5), std::sqrt(0.5)};
+    if (2 * m > n) {
+        const std::array<double, 2> p = quarterArc(n - m, n);
+        return {p[1], p[0]};
+    }
+    const double t = (std::numbers::pi / 2.0) * m / n;
+    return {std::cos(t), std::sin(t)};
+}
+
+using V3 = std::array<double, 3>;
+V3 cross(const V3& a, const V3& b) {
+    return {a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]};
+}
+V3 normalized(const V3& v) {
+    const double l = std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    return {v[0] / l, v[1] / l, v[2] / l};
+}
+
+// The unit-sphere point with barycentric weights a >= b >= c (a + b + c = n)
+// toward three orthogonal axes, as coordinates along those axes.
+V3 octaCanonical(int a, int b, int c, int n) {
+    if (b == 0) return {1.0, 0.0, 0.0};
+    if (c == 0) {
+        const std::array<double, 2> e = quarterArc(b, n);
+        return {e[0], e[1], 0.0};
+    }
+    // Upstream's construction, with its i, j, k = a, b, c.
+    const auto ac = [&](int m) { const auto e = quarterArc(m, n); return V3{e[0], 0.0, e[1]}; };
+    const auto bc = [&](int m) { const auto e = quarterArc(m, n); return V3{0.0, e[0], e[1]}; };
+    const auto ab = [&](int m) { const auto e = quarterArc(m, n); return V3{e[0], e[1], 0.0}; };
+    const auto meet = [](const V3& p, const V3& q, const V3& r, const V3& s) {
+        V3 x = normalized(cross(cross(p, q), cross(r, s)));
+        if (x[0] + x[1] + x[2] < 0) x = {-x[0], -x[1], -x[2]};  // the octant's side
+        return x;
+    };
+    const V3 xz_k = ac(c), yz_k = bc(c);
+    const V3 xy_j = ab(b), yz_j = bc(n - b);
+    const V3 xy_i = ab(n - a), xz_i = ac(n - a);
+    const V3 p1 = meet(xz_k, yz_k, xy_j, yz_j);
+    const V3 p2 = meet(xz_k, yz_k, xy_i, xz_i);
+    const V3 p3 = meet(xy_j, yz_j, xy_i, xz_i);
+    V3 p = normalized({p1[0] + p2[0] + p3[0], p1[1] + p2[1] + p3[1], p1[2] + p2[2] + p3[2]});
+    // Equal weights must give equal coordinates exactly, or the two
+    // permutations that swap them would disagree about this one vertex.
+    if (a == b) p[1] = p[0];
+    if (b == c) p[2] = p[1];
+    return p;
+}
+} // namespace
+
+SphereMesh buildOcta(double r, int segments) {
+    const int n = std::max(1, (segments + 3) / 4);
+    SphereMesh m;
+    std::map<std::array<int, 3>, int> index;  // signed barycentric weights -> vertex
+    const auto vertex = [&](int i, int j, int k, int sx, int sy, int sz) {
+        const std::array<int, 3> key{sx * i, sy * j, sz * k};
+        auto [it, fresh] = index.try_emplace(key, static_cast<int>(m.verts.size() / 3));
+        if (fresh) {
+            const std::array<int, 3> w{i, j, k};
+            std::array<int, 3> axis{0, 1, 2};
+            std::stable_sort(axis.begin(), axis.end(), [&](int p, int q) { return w[p] > w[q]; });
+            const V3 c = octaCanonical(w[axis[0]], w[axis[1]], w[axis[2]], n);
+            V3 p{};
+            for (int rank = 0; rank < 3; ++rank) p[axis[rank]] = c[rank];
+            pushVert(m, {r * sx * p[0], r * sy * p[1], r * sz * p[2]});
+        }
+        return it->second;
+    };
+    for (int sx : {1, -1})
+        for (int sy : {1, -1})
+            for (int sz : {1, -1}) {
+                const bool flip = sx * sy * sz < 0;
+                const auto tri = [&](int a, int b, int c) {
+                    if (flip) std::swap(b, c);
+                    m.tris.insert(m.tris.end(), {a, b, c});
+                };
+                // "Up" triangles toward +x, +y, +z, then the "down" ones
+                // between them; both wind outward in the (+,+,+) octant.
+                for (int i = 0; i < n; ++i)
+                    for (int j = 0; i + j < n; ++j) {
+                        const int k = n - 1 - i - j;
+                        tri(vertex(i + 1, j, k, sx, sy, sz), vertex(i, j + 1, k, sx, sy, sz),
+                            vertex(i, j, k + 1, sx, sy, sz));
+                        if (k >= 1)
+                            tri(vertex(i, j + 1, k, sx, sy, sz), vertex(i + 1, j, k, sx, sy, sz),
+                                vertex(i + 1, j + 1, k - 1, sx, sy, sz));
+                    }
+            }
+    return m;
+}
+
 // "icosa": subdivide every icosahedral face into a triangular grid and push
 // each sample out to the sphere. BOSL2 subsamples one face and rotates
 // copies onto the rest; sampling each face against its own corners is the
@@ -398,18 +513,10 @@ CSGParams resolveSphere(Evaluator& ev, const oscad::ModularCall& node, EvalConte
     params["segs"] = Value{static_cast<double>(hsides)};
     params["color"] = colorToValue(effCtx.color);
 
-    if (style == "octa") {
-        // Manifold::Sphere IS a subdivided octahedron (Shape::Octahedron,
-        // then Subdivide), so this needs no mesh of our own -- generate
-        // calls it directly.
-        params["verts"] = Value{makeList()};
-        params["tris"] = Value{makeList()};
-        return params;
-    }
-
     const SphereMesh m = style == "aligned"   ? buildAligned(r, hsides, vsides, false)
                          : style == "stagger" ? buildAligned(r, hsides, vsides, true)
                          : style == "icosa"   ? buildIcosa(r, hsides)
+                         : style == "octa"    ? buildOcta(r, hsides)
                                               : buildOrig(r, hsides, vsides);
 
     std::vector<Value> vertsValues;
@@ -433,11 +540,6 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
     for (const Value& t : std::get<ListPtr>(params.at("tris"))->items) {
         mesh.triVerts.push_back(static_cast<uint64_t>(std::get<double>(t)));
     }
-    if (std::get<std::string>(params.at("style")) == "octa") {
-        manifold::Manifold octa = manifold::Manifold::Sphere(
-            std::get<double>(params.at("r")), static_cast<int>(std::get<double>(params.at("segs"))));
-        return {ev.tagGenerated(std::move(octa), node, params.at("color"))};
-    }
     manifold::Manifold body(mesh);
     return {ev.tagGenerated(std::move(body), node, params.at("color"))};
 }

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/registry.cpp

@@ -138,14 +138,14 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"levelset", {"field", "bounds", "isovalue", "invert", "edge"}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
-        {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},
+        {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing", "em"}},
         // breakpoint() is this port's own debugger extension, no upstream
         // equivalent to mirror.
         {"breakpoint", {"condition"}},
 
         // -- the three builtin FUNCTIONS that do use Parameters::parse ----
-        {"textmetrics", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},
-        {"fontmetrics", {"size", "font"}},
+        {"textmetrics", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing", "em"}},
+        {"fontmetrics", {"size", "font", "em"}},
     };
     auto it = table.find(name);
     return it == table.end() ? nullptr : &it->second;

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/builtins/text.cpp

@@ -7,7 +7,7 @@
 
 #include <algorithm>
 
-// text(text=, size=10, font=, halign="default", valign="default", spacing=1,
+// text(text=, size=10 | em=, font=, halign="default", valign="default", spacing=1,
 // direction=, language=, script=) -- renders `text` as 2D glyph outlines
 // through the FontProvider (Evaluator::fontProvider(), lazily the built-in
 // FreetypeFontProvider if none was injected).
@@ -30,10 +30,24 @@ std::string asStringOr(const Value& v, const std::string& fallback) {
 }
 } // namespace
 
+double textSizeArg(Evaluator& ev, const CallArgs& args, std::optional<int> sizePos, std::optional<int> emPos,
+                   const char* caller, const oscad::Position* where) {
+    const Value em = getArg(args, emPos, "em");
+    const Value size = getArg(args, sizePos, "size");
+    if (std::holds_alternative<std::monostate>(em)) {
+        return std::holds_alternative<std::monostate>(size) ? 10.0 : toDoubleLenient(size);
+    }
+    if (!std::holds_alternative<std::monostate>(size)) {
+        ev.warn(std::string(caller) + ": \"size\" ignored when \"em\" is set", where);
+    }
+    return toDoubleLenient(em) * 72.0 / 100.0;
+}
+
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
-    const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
+    // em is name-only, like everything after font here.
+    const double size = textSizeArg(ev, args, 1, std::nullopt, "text", &node.position());
     // font is POSITIONAL, at index 2: `text("Hi", 10, "Liberation Sans")`
     // is how people write it and how the reference reads it -- measured
     // against the 2026.02.01 binary, whose bounding box for the

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/colored_body.cpp

@@ -40,9 +40,10 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
                 // slab finds the node that built the shape (see
                 // ColoredBody::sectionId). Manifold keeps a MeshGL's
                 // runOriginalID when it is given one.
-                manifold::MeshGL mesh = flat.body->GetMeshGL();
+                // MeshGL64: rebuilt below, and float32 would move every vertex.
+                manifold::MeshGL64 mesh = flat.body->GetMeshGL64();
                 mesh.runOriginalID = {*cb.sectionId};
-                mesh.runIndex = {0, static_cast<uint32_t>(mesh.triVerts.size())};
+                mesh.runIndex = {0, mesh.triVerts.size()};
                 mesh.runTransform.clear();
                 mesh.faceID.clear();
                 flat.body = manifold::Manifold(mesh);

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/src/csg_generate.cpp

@@ -364,7 +364,7 @@ std::shared_ptr<const std::vector<ColoredBody>> remapParts(const std::vector<Col
     for (ColoredBody part : parts) {
         if (part.mergedFrom) part.mergedFrom = remapParts(*part.mergedFrom, remap);
         if (part.body && !part.body->IsEmpty()) {
-            manifold::MeshGL mesh = part.body->GetMeshGL();
+            manifold::MeshGL64 mesh = part.body->GetMeshGL64();
             for (uint32_t& id : mesh.runOriginalID) {
                 auto found = remap.find(id);
                 if (found != remap.end()) id = found->second;
@@ -417,7 +417,14 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
             cb.sectionId = fresh;
         }
         if (!cb.body || cb.body->IsEmpty()) continue;
-        manifold::MeshGL mesh = cb.body->GetMeshGL();
+        // MeshGL64, not MeshGL: the body is rebuilt from this mesh below,
+        // and MeshGL is float32. Rounding every vertex made a cache hit a
+        // slightly different solid from the same shape built fresh, so
+        // difference() { sphere(50); sphere(50); } left a shell of slivers
+        // wherever one operand came from the cache -- only in the GUI,
+        // which has a cache, never in the CLI. A cube survived because its
+        // coordinates are exact in float32.
+        manifold::MeshGL64 mesh = cb.body->GetMeshGL64();
         if (mesh.runOriginalID.empty()) continue;
         std::unordered_map<uint32_t, uint32_t> remap;
         // fresh ID -> the colour its triangles carried, multi-colour

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/tests/test_manifold_cache.cpp

@@ -496,3 +496,26 @@ TEST(ManifoldCache, AHitOnAQuietSubtreeStaysQuiet) {
     EXPECT_EQ(countLines(), 0);
     EXPECT_EQ(countLines(), 0);
 }
+
+// A cache hit used to come back rebuilt through float32 (MeshGL), so the
+// second of two identical spheres was a slightly different solid from the
+// first and difference() left a shell of slivers -- in the GUI only, since
+// the CLI has no cache. A cube hid it: its coordinates are exact in float.
+// Covers the hit within one render, across renders, and the keep-minuend
+// path, which rebuilt its parts the same way.
+TEST(ManifoldCache, AHitIsTheSameSolidNotAFloatRoundedCopy) {
+    const std::string srcs[] = {
+        "difference() { sphere(d=100, $fn=16); sphere(d=100, $fn=16); }",
+        "difference() { sphere(d=100, style=\"octa\", $fn=16); sphere(d=100, style=\"octa\", $fn=16); }",
+        "difference() { rotate([10, 20, 30]) cylinder(h=7.3, r=3.1); rotate([10, 20, 30]) cylinder(h=7.3, r=3.1); }",
+    };
+    for (const std::string& src : srcs) {
+        auto cache = std::make_shared<ManifoldCache>();
+        for (int render = 0; render < 2; ++render) {
+            Evaluated e = evalSrcWithCache(src, cache);
+            for (const ColoredBody& b : e.bodies) {
+                EXPECT_TRUE(!b.body || b.body->IsEmpty()) << src << " render " << render;
+            }
+        }
+    }
+}

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/tests/test_primitives.cpp

@@ -3,7 +3,11 @@
 
 #include "test_helpers.hpp"
 
+#include <algorithm>
+#include <array>
 #include <cmath>
+#include <set>
+#include <string>
 #include <gtest/gtest.h>
 #include <numbers>
 
@@ -398,14 +402,45 @@ TEST(SphereStyle, EveryStyleMatchesBosl2sCounts) {
 }
 
 TEST(SphereStyle, EveryStyleMatchesBosl2sVolume) {
-    // aligned/stagger/icosa agree with BOSL2 to the last digit. "octa" comes
-    // from Manifold::Sphere, whose octahedral subdivision distributes its
-    // vertices a little differently than BOSL2's -- same 146/288 topology,
-    // ~0.05% apart in volume.
+    // aligned/stagger/icosa agree with BOSL2 to the last digit. "octa" is
+    // upstream OpenSCAD's construction (sphere(style="octa"), 2026-09), not
+    // BOSL2's -- same 146/288 topology. 4026.4886 is the hull volume of an
+    // independent port of upstream's createGeometryOcta.
     EXPECT_NEAR(sphereStats("sphere(r=10, style=\"aligned\", $fn=24);").volume, 4070.5524, 1e-3);
     EXPECT_NEAR(sphereStats("sphere(r=10, style=\"stagger\", $fn=24);").volume, 4082.1246, 1e-3);
     EXPECT_NEAR(sphereStats("sphere(r=10, style=\"icosa\", $fn=24);").volume, 4097.2467, 1e-3);
-    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"octa\", $fn=24);").volume, 4024.3239, 1e-3);
+    EXPECT_NEAR(sphereStats("sphere(r=10, style=\"octa\", $fn=24);").volume, 4026.4886, 1e-3);
+}
+
+// "octa" must be EXACTLY symmetric under the octahedron's 48 symmetries, not
+// to rounding: a copy rotated 90 degrees otherwise lands a hair off the
+// original, and difference() of the two leaves a mass of sliver shards
+// instead of nothing. It used to be Manifold::Sphere, symmetric to ~1e-15.
+TEST(SphereStyle, OctaIsExactlyOctahedrallySymmetric) {
+    for (int fn : {3, 8, 16, 21, 37, 64}) {
+        const std::string sphere = "sphere(d=100, style=\"octa\", $fn=" + std::to_string(fn) + ")";
+        Evaluated e = evalSrc(sphere + ";");
+        const manifold::MeshGL64 mesh = e.bodies[0].body->GetMeshGL64();
+        const size_t n = static_cast<size_t>(std::max(1, (fn + 3) / 4));
+        EXPECT_EQ(mesh.vertProperties.size() / 3, 4 * n * n + 2) << fn;
+        std::set<std::array<double, 3>> verts;
+        for (size_t v = 0; v < mesh.vertProperties.size(); v += 3)
+            verts.insert({mesh.vertProperties[v] + 0.0, mesh.vertProperties[v + 1] + 0.0, mesh.vertProperties[v + 2] + 0.0});
+        std::array<int, 3> perm{0, 1, 2};
+        do {
+            for (int signs = 0; signs < 8; ++signs) {
+                for (const std::array<double, 3>& p : verts) {
+                    std::array<double, 3> q{};
+                    for (int a = 0; a < 3; ++a) q[a] = ((signs >> a) & 1 ? -p[perm[a]] : p[perm[a]]) + 0.0;
+                    EXPECT_TRUE(verts.count(q)) << fn;
+                }
+            }
+        } while (std::next_permutation(perm.begin(), perm.end()));
+        for (const char* rot : {"[90,0,0]", "[0,90,0]", "[0,0,90]", "[180,0,0]"}) {
+            Evaluated d = evalSrc("difference() { " + sphere + "; rotate(" + rot + ") " + sphere + "; }");
+            for (const ColoredBody& b : d.bodies) EXPECT_TRUE(!b.body || b.body->IsEmpty()) << fn << " " << rot;
+        }
+    }
 }
 
 TEST(SphereStyle, EveryStyleIsAClosedSolidUnderTheTrueVolume) {

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/tests/test_text.cpp

@@ -192,6 +192,36 @@ TEST(Textmetrics, MultiByteUtf8CodepointsDecodeWithoutCrashing) {
     EXPECT_GT(asNum(items[0]), 0.0);
 }
 
+// em (upstream 2026-03, openscad #4304): `em` sets the em square, i.e.
+// size = em * 72/100, and wins over `size` with a warning. Positional at
+// index 9 in textmetrics and 2 in fontmetrics, as upstream's parameter
+// lists put it; text() takes it by name only, like its other options.
+TEST(Text, EmIsSizeTimes72Over100) {
+    const std::pair<const char*, std::vector<std::string>> cases[] = {
+        {"echo(str(textmetrics(\"Hi\", em=10)) == str(textmetrics(\"Hi\", size=7.2)));", {"ECHO: true"}},
+        {"echo(str(textmetrics(\"Hi\", 3, \"\", \"ltr\", \"en\", \"latin\", \"left\", \"baseline\", 1, 10))"
+         " == str(textmetrics(\"Hi\", size=7.2)));",
+         {"WARNING: textmetrics: \"size\" ignored when \"em\" is set in file <string>, line 1", "ECHO: true"}},
+        {"echo(str(fontmetrics(em=10)) == str(fontmetrics(size=7.2)));", {"ECHO: true"}},
+        // Inside a function, so the compiled (VM) call path is covered too.
+        {"function f() = textmetrics(\"Hi\", em=10); echo(str(f()) == str(textmetrics(\"Hi\", size=7.2)));",
+         {"ECHO: true"}},
+        {"echo(str(fontmetrics(undef, \"\", 10)) == str(fontmetrics(size=7.2)));", {"ECHO: true"}},
+        {"m = fontmetrics(size=3, em=10);",
+         {"WARNING: fontmetrics: \"size\" ignored when \"em\" is set in file <string>, line 1"}},
+        {"text(\"Hi\", size=3, em=10);",
+         {"WARNING: text: \"size\" ignored when \"em\" is set in file <string>, line 1"}},
+    };
+    for (const auto& [src, want] : cases) {
+        std::vector<std::string> log;
+        evalSrc(src, [&](const std::string& m) { log.push_back(m); });
+        EXPECT_EQ(log, want) << src;
+    }
+    Evaluated em = evalSrc("text(\"A\", em=10, $fn=32);");
+    Evaluated size = evalSrc("text(\"A\", size=7.2, $fn=32);");
+    EXPECT_NEAR(em.bodies[0].section->Area(), size.bodies[0].section->Area(), 1e-9);
+}
+
 // -- fontmetrics() --------------------------------------------------------
 
 TEST(Fontmetrics, ReturnsAllExpectedKeysInOrder) {

{openscad_cpp_evaluator-1.38.1 → openscad_cpp_evaluator-1.40.0}/uv.lock

@@ -55,7 +55,7 @@ wheels = [
 
 [[package]]
 name = "openscad-cpp-evaluator"
-version = "1.38.1"
+version = "1.40.0"
 source = { editable = "." }
 dependencies = [
     { name = "numpy" },