openscad-cpp-evaluator 1.11.0__tar.gz → 1.13.0__tar.gz

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/CLAUDE.md

@@ -793,6 +793,36 @@ grep for `ponytail:`.
   color instead of preserving each part's own, matching real OpenSCAD's actual behavior once fixed
   (cross-checked triangle-color-count-and-values against the Python reference directly, not just
   “does it run”).
+  Two things that pipeline depends on, both learned from BelfrySCAD #372 (`union() { color("red")
+  stroke(...); text(); }` came out entirely red):
+  **`color()` records its colour against the body's RUN IDS**, not only in `cb.color`
+  (`recordRunColors`, `color.cpp`). `tagGenerated()` covers a body coloured at birth — the colour
+  reaches a primitive through the context — but not one that already existed when colour was applied
+  to it, which is every module that wraps FORWARDED children: `module setcolor(clr) { color(clr)
+  children(); }` (BOSL2's `stroke()` has exactly that) generates the children in the caller's
+  colourless context, so nothing recorded them as red and after the merge every run looked
+  uncoloured. Uses `Manifold::OriginalID()` where the body is still one original, so the common case
+  costs no mesh build.
+  **An unknown run falls back to `nullopt`, never `cb.color`** — `cb.color` is the *first* child's
+  colour, so falling back to it made an uncoloured sibling look identically coloured, `allSame` came
+  out true, and nothing was tagged at all.
+  And the invariant behind both: **`triColors` must index the body's CURRENT mesh**. The renderer
+  masks its vertex arrays with it, so a stale length is an `IndexError` and a blank viewport rather
+  than a wrong colour. Anything that re-meshes clears it — `simplify()`, `minkowski_difference()`,
+  and the ID-retag rebuild when the triangle count moves — and `bodyToDict` drops a mismatched array
+  as a backstop for whichever one gets missed next.
+  **2D cannot use any of that, and keeps colour geometrically instead** (`Part2d`, same file): a
+  `CrossSection` is contours, not a mesh, so nothing in it remembers which child an edge came from
+  and there is no provenance for `attachTriColors` to read back. So the 2D accumulator holds **one
+  part per colour** rather than one merged section — same-coloured children still merge into one
+  part, a later statement notches what it covers out of the earlier parts (painter's order, the
+  rule `splitBodiesForExport` applies to overlapping 3D solids), `difference`/`intersection` apply
+  to every part, and a part cut away entirely is dropped. `generateCsg` then returns one
+  `ColoredBody` per surviving part, so **a 2D `union()` of differently-coloured children returns
+  several bodies where it used to return one**. Reported as a user bug: `union() { color("red")
+  square(10); color("blue") translate([12,0]) square(10); }` drew both squares red, where OpenSCAD
+  draws red and blue (verified by pixel-sampling both binaries' PNG output). `linear_extrude` of
+  such a union still drops colour entirely — checked against the real binary, which does the same.
 - `src/builtins/primitives_3d.cpp` — `sphere(style=)` is a BelfrySCAD extension naming the
   tessellation, using BOSL2's five `spheroid()` style names and constructions: `"orig"` (the default,
   and what OpenSCAD's own sphere() builds — rings offset half a step from the poles, no pole vertex),

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/bindings/module.cpp

@@ -168,6 +168,13 @@ nb::dict bodyToDict(oscadeval::ColoredBody& cb) {
     // (numTri, 4) float32 array or None). The renderer reads this to split
     // one merged body's triangles across separate opaque/translucent draw
     // buffers.
+    // Size-checked, not trusted: a per-triangle array that disagrees with
+    // the mesh it is meant to index makes the renderer raise IndexError and
+    // draw nothing. Dropping it costs the per-triangle colours of one body
+    // and keeps the model on screen. Everything that can invalidate it is
+    // supposed to clear it (simplify(), minkowski_difference(), the retag
+    // rebuild); this is the backstop for the one that gets missed.
+    if (cb.triColors && cb.triColors->size() != numTri) cb.triColors.reset();
     if (cb.triColors) {
         const std::vector<std::array<float, 4>>& src = *cb.triColors;
         std::vector<float> flat;

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -1237,6 +1237,13 @@ public:
     // it), which no RAII guard can span.
     bool measuring_ = false;
 
+    // True while a render() expression is measuring geometry it will then
+    // discard. The provenance tables (idToNode/idToColor) are not written
+    // during that, so anything outside this class applying the same guard
+    // -- color.cpp records run colours the way tagGenerated does -- reads
+    // it here.
+    bool measuring() const { return measuring_; }
+
     // Test-only accessors for the invariants above -- a leaked measuring_ or
     // an unbalanced treeStack_ is otherwise silent until something much
     // later goes mysteriously wrong.

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/booleans.cpp

@@ -184,7 +184,13 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
     perRunColor.reserve(runIds.size());
     for (uint32_t rid : runIds) {
         auto it = ev.idToColor.find(rid);
-        perRunColor.push_back(it != ev.idToColor.end() ? it->second : cb.color);
+        // nullopt, NOT cb.color, when a run has no recorded colour of its
+        // own. cb.color is the FIRST child's colour, so falling back to it
+        // made an uncoloured child look identically coloured, `allSame`
+        // came out true, and the whole merge kept one colour -- which is
+        // the "union() { color("red") a; b; } is all red" bug. nullopt is
+        // what an uncoloured body means everywhere else: follow the theme.
+        perRunColor.push_back(it != ev.idToColor.end() ? it->second : std::nullopt);
     }
     const bool allSame =
         std::all_of(perRunColor.begin(), perRunColor.end(), [&](const auto& c) { return c == perRunColor.front(); });
@@ -201,6 +207,57 @@ void attachTriColors(Evaluator& ev, ColoredBody& cb) {
     cb.triColors = std::move(triColors);
 }
 
+// One colour's worth of 2D result.
+//
+// 3D recovers per-child colour AFTER the merge, from Manifold's own
+// per-triangle provenance (attachTriColors above). A CrossSection has no
+// such thing -- it is contours, not a mesh, and nothing in it remembers
+// which child a given edge came from. So 2D has to keep colour
+// GEOMETRICALLY instead: one part per colour, each notched by whatever is
+// drawn over it later. That is the same painter's-order rule
+// splitBodiesForExport applies to overlapping 3D solids, and it is what
+// `union() { color("red") square(10); color("blue") ... }` needs to come
+// out as two coloured shapes instead of one shape wearing the first
+// child's colour.
+struct Part2d {
+    std::optional<std::array<float, 4>> color;
+    manifold::CrossSection section;
+};
+
+// Appends `add` to `parts`, merging into an existing part of the same
+// colour so `union() { color("red") a; color("red") b; }` stays one body.
+void addPart(std::vector<Part2d>& parts, const std::optional<std::array<float, 4>>& color,
+             const manifold::CrossSection& section) {
+    for (Part2d& p : parts) {
+        if (p.color == color) {
+            p.section = p.section + section;
+            return;
+        }
+    }
+    parts.push_back({color, section});
+}
+
+// The 2D operands of one statement, grouped by colour.
+std::vector<Part2d> partsOf(const std::vector<ColoredBody>& sections2d) {
+    std::vector<Part2d> parts;
+    for (const ColoredBody& c : sections2d) addPart(parts, c.color, *c.section);
+    return parts;
+}
+
+// Every part's section unioned -- the shape the statement covers,
+// whatever colours it is in.
+manifold::CrossSection coveredBy(const std::vector<Part2d>& parts) {
+    manifold::CrossSection all;
+    for (const Part2d& p : parts) all = all + p.section;
+    return all;
+}
+
+void dropEmptyParts(std::vector<Part2d>& parts) {
+    parts.erase(std::remove_if(parts.begin(), parts.end(),
+                                [](const Part2d& p) { return p.section.IsEmpty(); }),
+                parts.end());
+}
+
 } // namespace
 
 std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, const std::vector<std::unique_ptr<CSGNode>>& children,
@@ -222,7 +279,12 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
     // part-way. difference and intersection still see one dimension only:
     // applyDimensionRules drops the mismatch before it gets here, so for
     // them just one of these is ever populated.
-    std::optional<ColoredBody> res3d, res2d;
+    std::optional<ColoredBody> res3d;
+    // 2D keeps one entry per colour rather than one merged section; see
+    // Part2d. `have2d` distinguishes "no 2D operand yet" from "every 2D
+    // part has been cut away", which matters to difference().
+    std::vector<Part2d> res2d;
+    bool have2d = false;
     size_t idx = 0;
 
     size_t stmtIndex = 0;
@@ -282,10 +344,11 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             // union just skips the empty contributor and keeps going.
             if (op == "intersection") {
                 res3d.reset();
-                res2d.reset();
+                res2d.clear();
+                have2d = false;
                 break;
             }
-            if (op == "difference" && !res3d && !res2d) break;
+            if (op == "difference" && !res3d && !have2d) break;
             continue;
         }
 
@@ -309,20 +372,25 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
             }
         }
         if (!sections2d.empty()) {
-            manifold::CrossSection grp = *sections2d.front().section;
-            for (size_t i = 1; i < sections2d.size(); ++i) grp = grp + *sections2d[i].section;
-            if (!res2d) {
-                ColoredBody cb;
-                cb.section = std::move(grp);
-                cb.color = sections2d.front().color;
-                res2d = std::move(cb);
+            std::vector<Part2d> stmtParts = partsOf(sections2d);
+            const manifold::CrossSection grp = coveredBy(stmtParts);
+            if (!have2d) {
+                res2d = std::move(stmtParts);
+                have2d = true;
             } else if (op == "union") {
-                res2d->section = *res2d->section + grp;
+                // Later wins the overlap: notch what is already there by
+                // everything this statement covers, then add this
+                // statement's parts. Same rule as two overlapping 3D
+                // solids of different colours, and the same thing a
+                // painter does.
+                for (Part2d& p : res2d) p.section = p.section - grp;
+                for (Part2d& np : stmtParts) addPart(res2d, np.color, np.section);
             } else if (op == "difference") {
-                res2d->section = *res2d->section - grp;
+                for (Part2d& p : res2d) p.section = p.section - grp;
             } else if (op == "intersection") {
-                res2d->section = *res2d->section ^ grp;
+                for (Part2d& p : res2d) p.section = p.section ^ grp;
             }
+            dropEmptyParts(res2d);
         }
     }
 
@@ -330,7 +398,12 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
 
     std::vector<ColoredBody> result;
     if (res3d) result.push_back(std::move(*res3d));
-    if (res2d) result.push_back(std::move(*res2d));
+    for (Part2d& p : res2d) {
+        ColoredBody cb;
+        cb.color = p.color;
+        cb.section = std::move(p.section);
+        result.push_back(std::move(cb));
+    }
     result.insert(result.end(), allBg.begin(), allBg.end());
     result.insert(result.end(), allHi.begin(), allHi.end());
     result.insert(result.end(), allSo.begin(), allSo.end());

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/color.cpp

@@ -50,12 +50,42 @@ CSGParams resolveColor(Evaluator& ev, const oscad::ModularCall& node, EvalContex
     return std::move(result.params);
 }
 
-std::vector<ColoredBody> generateColor(Evaluator&, const CSGParams& params,
+namespace {
+
+// Stamping cb.color is not enough: the colour has to be recorded against
+// the body's RUN IDS too.
+//
+// attachTriColors (booleans.cpp) reads `idToColor` back AFTER a merge has
+// thrown the individual bodies away -- run IDs are all it has left to go
+// on -- and a run it cannot find looks uncoloured. tagGenerated() records
+// the colour a body was BORN with, which covers `color("red") cube(10)`
+// because the colour reaches the primitive through the context. It does
+// not cover a body that already existed when colour was applied to it,
+// which is every module whose geometry comes out of its own CSG:
+// `union() { color("red") stroke(...); text(); }` had no red recorded for
+// the stroke's runs at all, so every run looked identical, the merge kept
+// the first child's colour, and the whole thing came out red.
+void recordRunColors(Evaluator& ev, const ColoredBody& b, const std::optional<std::array<float, 4>>& rgba) {
+    if (!b.body || b.body->IsEmpty()) return;
+    // A body that is still one original knows its own ID without building
+    // a mesh -- the common case, and the cheap one.
+    const int original = b.body->OriginalID();
+    if (original >= 0) {
+        ev.idToColor[static_cast<uint32_t>(original)] = rgba;
+        return;
+    }
+    for (uint32_t id : b.body->GetMeshGL().runOriginalID) ev.idToColor[id] = rgba;
+}
+
+} // namespace
+
+std::vector<ColoredBody> generateColor(Evaluator& ev, const CSGParams& params,
                                         const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode&) {
     const auto rgba = valueToColor(params.at("rgba"));
     std::vector<ColoredBody> result;
     for (ColoredBody b : flattenCsgTree(children)) {
         b.color = rgba;
+        if (!ev.measuring()) recordRunColors(ev, b, rgba);
         result.push_back(std::move(b));
     }
     return result;

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/src/builtins/topology.cpp

@@ -481,7 +481,14 @@ std::vector<ColoredBody> generateSimplify(Evaluator& ev, const CSGParams& params
                 const manifold::vec3 d = bb.Size();
                 tol = kDefaultSimplifyFraction * std::sqrt(d.x * d.x + d.y * d.y + d.z * d.z);
             }
-            if (tol > 0.0) cb.body = b.body->Simplify(tol);
+            if (tol > 0.0) {
+                cb.body = b.body->Simplify(tol);
+                // triColors is indexed by triangle, and decimation changes
+                // how many there are -- carrying it across leaves the
+                // renderer masking a 550-triangle mesh with a 556-entry
+                // array, which is an IndexError, not a wrong colour.
+                cb.triColors.reset();
+            }
         } else if (b.section) {
             double tol = explicitValue;
             if (!explicitTol) {

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/src/csg_generate.cpp

@@ -331,7 +331,16 @@ void Evaluator::restampCachedIds(std::vector<ColoredBody>& bodies, const oscad::
             }
             id = found->second;
         }
+        const size_t trisBefore = mesh.triVerts.size() / 3;
         cb.body = manifold::Manifold(mesh);
+        // Rebuilding a Manifold from a mesh can clean it up (degenerate
+        // triangles merged away), and triColors is indexed by triangle. An
+        // array that no longer matches is worse than none: the renderer
+        // masks its vertex arrays with it and raises IndexError rather
+        // than drawing anything at all.
+        if (cb.triColors && cb.body && cb.body->GetMeshGL().triVerts.size() / 3 != trisBefore) {
+            cb.triColors.reset();
+        }
     }
 }
 

{openscad_cpp_evaluator-1.11.0 → openscad_cpp_evaluator-1.13.0}/tests/test_booleans.cpp

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <gtest/gtest.h>
+#include <set>
 
 using namespace oscadeval;
 using namespace oscadeval::test;
@@ -1439,3 +1440,196 @@ TEST(LevelSet, AGridFieldIsAlsoCutCleanlyAtTheBox) {
     ASSERT_EQ(e.bodies.size(), 1u);
     EXPECT_NEAR(soleBody(e).Volume(), 32000.0, 40.0);   // one sample layer of slack
 }
+
+// -- 2D union keeps every colour (bug report: "multiple colors inside a
+// union(), only one color is used") -----------------------------------
+
+namespace {
+
+// (colour, area) per 2D body, in result order.
+std::vector<std::pair<std::array<float, 4>, double>> colouredAreas(const std::vector<ColoredBody>& bodies) {
+    std::vector<std::pair<std::array<float, 4>, double>> out;
+    for (const ColoredBody& b : bodies) {
+        if (!b.section) continue;
+        out.emplace_back(b.color.value_or(std::array<float, 4>{0, 0, 0, 0}), b.section->Area());
+    }
+    return out;
+}
+
+constexpr std::array<float, 4> kRed{1, 0, 0, 1};
+constexpr std::array<float, 4> kBlue{0, 0, 1, 1};
+
+} // namespace
+
+TEST(Union2dColor, KeepsOneBodyPerColour) {
+    // A CrossSection has no per-edge provenance for attachTriColors to read
+    // back afterwards, so 2D keeps colour by staying in separate parts.
+    // Before this, both squares came out red -- the first child's colour
+    // for the whole merged section, where OpenSCAD draws red AND blue.
+    Evaluated e = evalSrc("union() { color(\"red\") square(10); color(\"blue\") translate([12,0]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    EXPECT_NEAR(parts[0].second, 100.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 100.0, 1e-6);
+}
+
+TEST(Union2dColor, OneColourStaysOneBody) {
+    // Splitting per colour must not split per child: two red squares are
+    // one red shape, as they always were.
+    Evaluated e = evalSrc("union() { color(\"red\") square(10); color(\"red\") translate([12,0]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 1u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_NEAR(parts[0].second, 200.0, 1e-6);
+}
+
+TEST(Union2dColor, AnUncolouredUnionIsStillASingleBody) {
+    Evaluated e = evalSrc("union() { square(10); translate([12,0]) square(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].section.has_value());
+    EXPECT_FALSE(e.bodies[0].color.has_value());
+}
+
+TEST(Union2dColor, TheLaterColourWinsAnOverlap) {
+    // Painter's order, the same rule splitBodiesForExport applies to
+    // overlapping 3D solids -- and what OpenSCAD's own preview shows.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") square(10); color(\"blue\") translate([5,5]) square(10); }");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    // Blue keeps its whole square; red is notched by the 5x5 overlap.
+    EXPECT_NEAR(parts[1].second, 100.0, 1e-6);
+    EXPECT_NEAR(parts[0].second, 75.0, 1e-6);
+}
+
+TEST(Union2dColor, DifferenceCutsEveryColouredPart) {
+    Evaluated e = evalSrc(
+        "difference() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([10,0]) square(10); }"
+        "  translate([5,0]) square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    // The cut spans both: 5 wide off red's right, 5 off blue's left.
+    EXPECT_NEAR(parts[0].second, 50.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 50.0, 1e-6);
+}
+
+TEST(Union2dColor, IntersectionKeepsColoursToo) {
+    Evaluated e = evalSrc(
+        "intersection() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([10,0]) square(10); }"
+        "  translate([5,0]) square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 2u);
+    EXPECT_EQ(parts[0].first, kRed);
+    EXPECT_EQ(parts[1].first, kBlue);
+    EXPECT_NEAR(parts[0].second, 50.0, 1e-6);
+    EXPECT_NEAR(parts[1].second, 50.0, 1e-6);
+}
+
+TEST(Union2dColor, APartCutAwayEntirelyIsDropped) {
+    Evaluated e = evalSrc(
+        "difference() {"
+        "  union() { color(\"red\") square(10); color(\"blue\") translate([20,0]) square(10); }"
+        "  square(10);"
+        "}");
+    const auto parts = colouredAreas(e.bodies);
+    ASSERT_EQ(parts.size(), 1u);
+    EXPECT_EQ(parts[0].first, kBlue);
+}
+
+TEST(Union2dColor, ExtrudingAColouredUnionStillDropsColour) {
+    // Not a bug, and checked against the real binary: OpenSCAD's own
+    // linear_extrude of coloured 2D children draws the default colour too.
+    // Splitting 2D by colour must not accidentally start colouring these.
+    Evaluated e = evalSrc(
+        "linear_extrude(5) union() { color(\"red\") square(10); color(\"blue\") translate([12,0]) square(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].body.has_value());
+    EXPECT_FALSE(e.bodies[0].color.has_value());
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 1000.0, 1e-6);
+}
+
+
+// -- 3D colour survives a merge (BelfrySCAD #372) -------------------------
+
+namespace {
+
+std::set<std::array<float, 4>> distinctTriColors(const ColoredBody& b) {
+    std::set<std::array<float, 4>> out;
+    if (b.triColors) out.insert(b.triColors->begin(), b.triColors->end());
+    return out;
+}
+
+} // namespace
+
+TEST(Union3dColor, ColourAppliedToForwardedChildrenSurvivesTheMerge) {
+    // The reported case, reduced out of BOSL2. Its stroke() colours what
+    // it draws through exactly this shape -- a module that wraps FORWARDED
+    // children in color(). The children were generated in the caller's
+    // context, where there is no colour, so tagGenerated() recorded them as
+    // uncoloured; color() then stamped cb.color and nothing else. After the
+    // merge, attachTriColors had only run IDs to go on, every one of them
+    // looked uncoloured, they all "matched", and the union kept the first
+    // child's colour -- the whole model came out red.
+    Evaluated e = evalSrc(
+        "module setcolor(clr) { color(clr) children(); }\n"
+        "union() {"
+        "  setcolor(\"red\") cube(10);"
+        "  translate([12,0,0]) cube(10);"
+        "}");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    const auto colours = distinctTriColors(e.bodies[0]);
+    EXPECT_EQ(colours.size(), 2u);
+    EXPECT_EQ(colours.count(std::array<float, 4>{1, 0, 0, 1}), 1u);
+}
+
+TEST(Union3dColor, AnUncolouredChildDoesNotInheritTheColouredOne) {
+    // perRunColor's fallback used to be cb.color -- the FIRST child's
+    // colour -- so an uncoloured sibling looked identically coloured, the
+    // "do the colours differ?" test said no, and nothing was tagged at all.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") cube(10); translate([12,0,0]) cube(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    const auto colours = distinctTriColors(e.bodies[0]);
+    EXPECT_EQ(colours.size(), 2u);
+    EXPECT_EQ(colours.count(std::array<float, 4>{1, 0, 0, 1}), 1u);
+    // ... and the other half is the default, not red.
+    for (const auto& c : colours) {
+        if (c != std::array<float, 4>{1, 0, 0, 1}) EXPECT_NE(c[0], 1.0f);
+    }
+}
+
+TEST(Union3dColor, EveryTriangleIsAccountedFor) {
+    // triColors must index the body's CURRENT mesh exactly: the renderer
+    // masks its vertex arrays with it, so a stale length is an IndexError
+    // and a blank viewport, not a wrong colour.
+    Evaluated e = evalSrc(
+        "union() { color(\"red\") cube(10); color(\"blue\") translate([12,0,0]) cube(10); }");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    ASSERT_TRUE(e.bodies[0].triColors.has_value());
+    EXPECT_EQ(e.bodies[0].triColors->size(), e.bodies[0].body->GetMeshGL().triVerts.size() / 3);
+}
+
+TEST(Union3dColor, SimplifyDropsPerTriangleColoursRatherThanKeepingStaleOnes) {
+    // Decimation changes the triangle count; an array indexed against the
+    // old one cannot be salvaged, and handing it on crashes the renderer.
+    Evaluated e = evalSrc(
+        "simplify(0.5) union() {"
+        "  color(\"red\") sphere(10, $fn=32);"
+        "  color(\"blue\") translate([25,0,0]) sphere(10, $fn=32);"
+        "}");
+    ASSERT_FALSE(e.bodies.empty());
+    for (const ColoredBody& b : e.bodies) {
+        if (!b.body || !b.triColors) continue;
+        EXPECT_EQ(b.triColors->size(), b.body->GetMeshGL().triVerts.size() / 3);
+    }
+}