openscad-cpp-evaluator 1.12.0__tar.gz → 1.14.0__tar.gz

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/CLAUDE.md

@@ -276,7 +276,16 @@ OpenSCAD's `detect_properties()`/`detect_script()` does by hand.
 `resolveFont()` never fails. An unmatched family falls back to the bundled Liberation Sans
 (`resources/fonts/`, embedded into the binary by `cmake/embed_font.cmake`, byte-identical to the
 Python reference's own bundled font), which is both the default and the last-resort fallback — so
-`text()` draws something even on a machine with no fonts installed at all. That mirrors
+`text()` draws something even on a machine with no fonts installed at all.
+**All four styles are bundled** (Regular, Bold, Italic, Bold Italic), and they are seeded into the
+face index ahead of anything installed, so `style=` resolves the same way on every machine.
+Bundling only Regular meant a `style=Bold` nothing installed could satisfy fell silently back to
+Regular — `fontmetrics(10, "Liberation Sans:style=bold")` then reported Regular's numbers under
+the name the script asked for (BelfrySCAD #381). A bundled entry's `path` is the sentinel
+`"<bundled>"` and its `faceIndex` is the already-open handle, so `resolveFont` opens no file for it.
+`FreetypeFontProvider::listFonts()` returns every resolvable face (family, style, path), sorted and
+deduplicated by family+style — reached from Python as `list_fonts()`, which adds the exact `font=`
+spec for each. It is the only call here that forces the system scan the rest of the class defers. That mirrors
 fontconfig's own never-fails matching, and so real OpenSCAD's: a missing font silently becomes the
 nearest available one rather than an error.
 
@@ -289,6 +298,14 @@ variable real OpenSCAD reads). Family match is case-insensitive and required; st
 dropping to Regular beats falling through to an unrelated family, which is what fontconfig does
 too.
 
+**`font` is a POSITIONAL argument in both metrics functions**, and so is everything after it:
+`fontmetrics(size, font)` and `textmetrics(text, size, font, direction, language, script, halign,
+valign, spacing)`. Verified against the 2026.02.01 binary rather than read off a doc page. Having
+`font` name-only meant `fontmetrics(10, "Liberation Sans:style=Bold")` — how the bug report was
+written, and how real OpenSCAD reads it — was taken as *no font at all*, so the default face was
+measured and reported under the requested name. That was the visible half of BelfrySCAD #381; the
+bundled-styles gap above was the other.
+
 `text_metrics.hpp`/`.cpp` holds the shared layout math (`measureText`/`textAlignOffset`) used by
 both `text()` (`builtins/text.cpp`) and `textmetrics()`/`fontmetrics()` (`function_builtins.cpp`).
 Sharing it is the point: the numbers a script positions against cannot disagree with what it
@@ -793,6 +810,24 @@ 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

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/CMakeLists.txt

@@ -218,13 +218,30 @@ FetchContent_MakeAvailable(cpp_linenoise)
 # a real installed/packaged build (e.g. the PyPI wheel) has no guarantee the
 # source tree's resources/fonts/ is present or at any predictable path
 # alongside the installed shared library.
-set(BUNDLED_FONT_SRC ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Regular.ttf)
+# The whole Liberation Sans family, not just Regular: a `style=` that
+# cannot be satisfied silently falls back to the regular face, which is
+# what made fontmetrics(10, "Liberation Sans:style=bold") report Regular's
+# numbers (BelfrySCAD #381). Regular stays FIRST -- it is the default face
+# and the last-resort fallback.
+set(BUNDLED_FONT_SRCS
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Regular.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Bold.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-Italic.ttf
+  ${CMAKE_CURRENT_SOURCE_DIR}/resources/fonts/LiberationSans-BoldItalic.ttf
+)
 set(BUNDLED_FONT_HEADER ${CMAKE_CURRENT_BINARY_DIR}/generated/openscad_cpp_evaluator/bundled_font_data.hpp)
+# Joined into ONE argument, and quoted. Left as a ";" list,
+# add_custom_command expands it into separate arguments and the font paths
+# land where -P expects the script; joined with "|" but unquoted, make
+# emits a bare pipe and the shell splits the command in two. The separator
+# is "@" for the same reason -- no shell meaning, and no filesystem here
+# puts one in a path.
+string(REPLACE ";" "@" BUNDLED_FONT_SRCS_ARG "${BUNDLED_FONT_SRCS}")
 add_custom_command(
   OUTPUT ${BUNDLED_FONT_HEADER}
-  COMMAND ${CMAKE_COMMAND} -DIN_FILE=${BUNDLED_FONT_SRC} -DOUT_FILE=${BUNDLED_FONT_HEADER}
+  COMMAND ${CMAKE_COMMAND} "-DIN_FILES=${BUNDLED_FONT_SRCS_ARG}" -DOUT_FILE=${BUNDLED_FONT_HEADER}
           -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
-  DEPENDS ${BUNDLED_FONT_SRC} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
+  DEPENDS ${BUNDLED_FONT_SRCS} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/embed_font.cmake
   COMMENT "Embedding bundled font bytes into bundled_font_data.hpp"
 )
 add_custom_target(generate_bundled_font DEPENDS ${BUNDLED_FONT_HEADER})

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/bindings/module.cpp

@@ -23,6 +23,7 @@
 #include "openscad_cpp_evaluator/eval_use.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/export.hpp"
+#include "openscad_cpp_evaluator/freetype_font_provider.hpp"
 #include "openscad_cpp_evaluator/mesh_check.hpp"
 #include "openscad_cpp_evaluator/manifold_cache.hpp"
 #include "openscad_cpp_evaluator/profile.hpp"
@@ -168,6 +169,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;
@@ -862,6 +870,31 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "add-meta-data, title, author, subject, keywords). An unknown key raises rather than "
           "being ignored. .pdf is 2D-only too, and centres the drawing on a fixed paper size.");
 
+    m.def("list_fonts", []() {
+        nb::list out;
+        oscadeval::FreetypeFontProvider provider;
+        for (const oscadeval::FontFace& f : provider.listFonts()) {
+            nb::dict d;
+            d["family"] = f.family;
+            d["style"] = f.style;
+            // The exact string to put in font=. Style included only when
+            // it is not the plain face: "Liberation Sans" is what you
+            // write for Regular, and printing the longer form for it would
+            // teach the wrong habit.
+            const bool plain = f.style.empty() || f.style == "Regular";
+            d["spec"] = plain ? f.family : f.family + ":style=" + f.style;
+            d["path"] = f.path;
+            out.append(d);
+        }
+        return out;
+    },
+          "Every font text()/textmetrics()/fontmetrics() can resolve: family, style, the exact "
+          "`font=` spec that selects it, and the file it comes from (\"<bundled>\" for the "
+          "faces shipped with this package). Read from the same FreeType index those functions "
+          "match against, NOT from the windowing toolkit -- a system font database names faces "
+          "differently, which is the whole reason a list is worth showing. Scans the system font "
+          "directories, so it costs real time on a machine with many fonts.");
+
     m.def("export_extensions", []() { return oscadeval::exportExtensions(); },
           "The file extensions export_model understands, dot-prefixed. Read from the C++ writer table "
           "rather than restated here, so the Python side cannot drift from what can actually be written.");

openscad_cpp_evaluator-1.14.0/cmake/embed_font.cmake

@@ -0,0 +1,71 @@
+# Reads IN_FILES (a ";"-separated list of binaries) and writes OUT_FILE: a
+# C++ header exposing their bytes as static arrays, plus a kBundledFonts
+# table over them. Run via
+# `cmake -DIN_FILES="a.ttf;b.ttf" -DOUT_FILE=... -P embed_font.cmake` as a
+# build-time add_custom_command, not configure_file -- fonts baked in as
+# bytes have no runtime file path to go stale once the shared library is
+# installed somewhere other than its own build tree (see this script's own
+# call site in the top-level CMakeLists.txt for the packaging bug this
+# replaces).
+#
+# More than one font, because a style= that cannot be satisfied is worse
+# than useless: it silently returns the regular face, which is what made
+# `fontmetrics(10, "Liberation Sans:style=bold")` report Regular's numbers
+# (BelfrySCAD #381). The whole family is embedded so the styles a script
+# asks for exist even on a machine with no fonts of its own.
+if(NOT DEFINED IN_FILES OR NOT DEFINED OUT_FILE)
+    message(FATAL_ERROR "embed_font.cmake requires -DIN_FILES=... -DOUT_FILE=...")
+endif()
+
+# "@"-joined by the caller into a single argument; see the call site for
+# why neither a ";" list nor a "|" join survives the trip.
+string(REPLACE "@" ";" IN_FILES "${IN_FILES}")
+
+set(_decls "")
+set(_table "")
+set(_index 0)
+foreach(_file IN LISTS IN_FILES)
+    file(READ "${_file}" _hex HEX)
+    string(LENGTH "${_hex}" _hexLen)
+    math(EXPR _byteCount "${_hexLen} / 2")
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," _bytesCsv "${_hex}")
+    get_filename_component(_name "${_file}" NAME)
+    string(APPEND _decls
+"// ${_name}
+inline constexpr unsigned char kBundledFont${_index}[] = {
+${_bytesCsv}
+};
+")
+    string(APPEND _table "    {kBundledFont${_index}, ${_byteCount}},\n")
+    if(_index EQUAL 0)
+        set(_firstSize "${_byteCount}")
+    endif()
+    math(EXPR _index "${_index} + 1")
+endforeach()
+
+file(WRITE "${OUT_FILE}"
+"// Auto-generated by cmake/embed_font.cmake -- do not edit.
+#pragma once
+#include <cstddef>
+
+namespace oscadeval {
+
+${_decls}
+struct BundledFont {
+    const unsigned char* data;
+    std::size_t size;
+};
+
+// Index 0 is the default face and the last-resort fallback; the rest are
+// the other styles of the same family, so a `style=` request can be met
+// without anything installed on the machine.
+inline constexpr BundledFont kBundledFonts[] = {
+${_table}};
+inline constexpr std::size_t kBundledFontCount = ${_index};
+
+// The default face, named for the callers that only ever wanted that one.
+inline constexpr const unsigned char* kBundledFontData = kBundledFont0;
+inline constexpr std::size_t kBundledFontDataSize = ${_firstSize};
+
+} // namespace oscadeval
+")

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.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.12.0 → openscad_cpp_evaluator-1.14.0}/include/openscad_cpp_evaluator/freetype_font_provider.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "openscad_cpp_evaluator/font_match.hpp"
 #include "openscad_cpp_evaluator/font_provider.hpp"
 
 #include <memory>
@@ -30,6 +31,18 @@ public:
     std::optional<std::array<double, 4>> glyphInkBounds(FontHandle handle, GlyphId glyph) override;
     GlyphContours glyphOutline(FontHandle handle, GlyphId glyph, int segsPerCurve) override;
 
+    // Every face this provider can resolve: the bundled family first, then
+    // everything installed, sorted by family then style. Forces the system
+    // scan that the rest of the class defers, so it is the one call here
+    // that costs real time on a machine with a few hundred fonts.
+    //
+    // These are the names `font=` actually takes -- the point of showing
+    // them at all (BelfrySCAD #379: "the displayed font name can be
+    // different from the font name needed by OpenSCAD"). A list read from
+    // the windowing toolkit's font database would reproduce exactly that
+    // mismatch.
+    std::vector<FontFace> listFonts();
+
 private:
     struct Impl;
     std::unique_ptr<Impl> impl_;

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.0}/python/openscad_cpp_evaluator/__init__.py

@@ -20,7 +20,7 @@ __all__ = [
     "ManifoldCache", "CallSiteProfile", "ProfileResult", "format_csg_tree", "bodies_from_dicts",
     "FastContinueSignal", "parse_ast", "parse_ast_string", "format_source",
     "check_mesh", "strip_slivers",
-    "export_model", "export_extensions",
+    "export_model", "export_extensions", "list_fonts",
 ]
 
 
@@ -342,6 +342,23 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
         raise EvalError(str(e)) from e
 
 
+def list_fonts() -> list:
+    """Every font `text()`/`textmetrics()`/`fontmetrics()` can resolve.
+
+    A list of dicts with `family`, `style`, `spec` and `path`. `spec` is
+    the exact string to put in `font=`, which is the point of asking:
+    the name a system font dialog shows is often not the name OpenSCAD
+    takes, and this list comes from the same FreeType index the text
+    functions match against. `path` is `"<bundled>"` for the faces
+    shipped with this package.
+
+    Scans the system font directories, so it costs real time on a machine
+    with many fonts -- call it when someone asks to see the list, not on
+    a hot path.
+    """
+    return list(_ext.list_fonts())
+
+
 def export_extensions() -> list:
     """The file extensions export_model understands, dot-prefixed.
 

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.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(); });

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.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.12.0 → openscad_cpp_evaluator-1.14.0}/src/builtins/function_builtins.cpp

@@ -785,14 +785,21 @@ Value objectOf(std::vector<std::pair<std::string, Value>> items) {
 Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
     const std::string text = asStringOr(getArg(args, 0, "text", Value{std::string("")}), "");
     const double size = toDoubleLenient(getArg(args, 1, "size", Value{10.0}));
-    const std::string halign = asStringOr(getArg(args, std::nullopt, "halign", Value{std::string("left")}), "left");
-    const std::string valign = asStringOr(getArg(args, std::nullopt, "valign", Value{std::string("baseline")}), "baseline");
-    const double spacing = toDoubleLenient(getArg(args, std::nullopt, "spacing", Value{1.0}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // 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 --
+    // 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
+    // measure the default face (BelfrySCAD #381).
+    const std::string halign = asStringOr(getArg(args, 6, "halign", Value{std::string("left")}), "left");
+    const std::string valign = asStringOr(getArg(args, 7, "valign", Value{std::string("baseline")}), "baseline");
+    const double spacing = toDoubleLenient(getArg(args, 8, "spacing", Value{1.0}));
+    const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     ShapeOptions shape;
-    shape.direction = asStringOr(getArg(args, std::nullopt, "direction", Value{std::string("")}), "");
-    shape.language = asStringOr(getArg(args, std::nullopt, "language", Value{std::string("")}), "");
-    shape.script = asStringOr(getArg(args, std::nullopt, "script", Value{std::string("")}), "");
+    shape.direction = asStringOr(getArg(args, 3, "direction", Value{std::string("")}), "");
+    shape.language = asStringOr(getArg(args, 4, "language", Value{std::string("")}), "");
+    shape.script = asStringOr(getArg(args, 5, "script", Value{std::string("")}), "");
 
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);
@@ -813,7 +820,9 @@ Value builtinTextmetrics(Evaluator& ev, const CallArgs& args) {
 // 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}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // 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("")}), "");
 
     FontProvider& fp = ev.fontProvider();
     const FontHandle handle = fp.resolveFont(fontSpec);

{openscad_cpp_evaluator-1.12.0 → openscad_cpp_evaluator-1.14.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.12.0 → openscad_cpp_evaluator-1.14.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.12.0 → openscad_cpp_evaluator-1.14.0}/src/text/freetype_font_provider.cpp

@@ -1,5 +1,7 @@
 #include "openscad_cpp_evaluator/freetype_font_provider.hpp"
 
+#include <algorithm>
+
 #include "openscad_cpp_evaluator/bundled_font_data.hpp"
 #include "openscad_cpp_evaluator/font_match.hpp"
 
@@ -104,6 +106,11 @@ struct FreetypeFontProvider::Impl {
         FontMetrics metrics;
     };
 
+    //: A FontFace whose `path` is this is already open: its faceIndex IS
+    //: the handle. Real paths cannot collide with it -- no filesystem
+    //: yields a name in angle brackets from findFontFiles().
+    static constexpr const char* kBundledPath = "<bundled>";
+
     std::vector<Face> faces;                                 // handle == index
     std::unordered_map<std::string, FontHandle> bySpec;      // resolved spec -> handle
     std::vector<FontFace> installed;                         // system font index
@@ -160,21 +167,30 @@ struct FreetypeFontProvider::Impl {
         return faces.size() - 1;
     }
 
+    // Every bundled face, in order -- handle 0 is the regular one, the
+    // default and the last-resort fallback. The rest are the other styles
+    // of the same family: a `style=` request that nothing installed can
+    // satisfy used to fall silently back to regular, which is what made
+    // fontmetrics("Liberation Sans:style=bold") report Regular's numbers
+    // (BelfrySCAD #381).
     void openBundled() {
-        Face f;
-        if (FT_New_Memory_Face(lib, reinterpret_cast<const FT_Byte*>(kBundledFontData),
-                               static_cast<FT_Long>(kBundledFontDataSize), 0, &f.ft) != 0) {
-            throw std::runtime_error("FreetypeFontProvider: bundled font failed to load");
+        for (std::size_t i = 0; i < kBundledFontCount; ++i) {
+            const BundledFont& src = kBundledFonts[i];
+            Face f;
+            if (FT_New_Memory_Face(lib, reinterpret_cast<const FT_Byte*>(src.data),
+                                   static_cast<FT_Long>(src.size), 0, &f.ft) != 0) {
+                if (i == 0) throw std::runtime_error("FreetypeFontProvider: bundled font failed to load");
+                continue;  // a spare style is not worth failing every render for
+            }
+            f.blob = hb_blob_create(reinterpret_cast<const char*>(src.data),
+                                    static_cast<unsigned>(src.size), HB_MEMORY_MODE_READONLY, nullptr, nullptr);
+            f.hbFace = hb_face_create(f.blob, 0);
+            f.hbFont = hb_font_create(f.hbFace);
+            hb_ot_font_set_funcs(f.hbFont);
+            f.metrics = readMetrics(f.ft);
+            scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
+            faces.push_back(f);
         }
-        f.blob = hb_blob_create(reinterpret_cast<const char*>(kBundledFontData),
-                                static_cast<unsigned>(kBundledFontDataSize), HB_MEMORY_MODE_READONLY, nullptr,
-                                nullptr);
-        f.hbFace = hb_face_create(f.blob, 0);
-        f.hbFont = hb_font_create(f.hbFace);
-        hb_ot_font_set_funcs(f.hbFont);
-        f.metrics = readMetrics(f.ft);
-        scaleHbFontToEm(f.hbFont, static_cast<unsigned>(f.metrics.unitsPerEm));
-        faces.push_back(f);
     }
 
     // Reads family/style out of every face of every installed font file.
@@ -185,6 +201,15 @@ struct FreetypeFontProvider::Impl {
     void scanInstalled() {
         if (scanned) return;
         scanned = true;
+        // The bundled faces go in FIRST, so what a given family+style
+        // resolves to does not depend on what the machine happens to have
+        // installed -- the same script draws the same shapes everywhere.
+        // Their "path" is the sentinel below and their faceIndex is the
+        // already-open handle, so resolveFont skips opening a file at all.
+        for (std::size_t i = 0; i < faces.size() && i < kBundledFontCount; ++i) {
+            installed.push_back(FontFace{std::string(kBundledPath), static_cast<int>(i),
+                                          faces[i].metrics.family, faces[i].metrics.style});
+        }
         for (const std::string& path : findFontFiles()) {
             FT_Face probe = nullptr;
             if (FT_New_Face(lib, path.c_str(), -1, &probe) != 0) continue;
@@ -222,12 +247,30 @@ FontHandle FreetypeFontProvider::resolveFont(const std::string& spec) {
     impl_->scanInstalled();
     FontHandle handle = 0;
     if (const std::optional<FontFace> hit = matchFace(parsed, impl_->installed)) {
-        handle = impl_->openFile(hit->path, hit->faceIndex).value_or(0);
+        handle = hit->path == Impl::kBundledPath ? static_cast<FontHandle>(hit->faceIndex)
+                                                  : impl_->openFile(hit->path, hit->faceIndex).value_or(0);
     }
     impl_->bySpec[spec] = handle;
     return handle;
 }
 
+std::vector<FontFace> FreetypeFontProvider::listFonts() {
+    impl_->scanInstalled();
+    std::vector<FontFace> out = impl_->installed;
+    // A family installed in several files, or listed both bundled and
+    // installed, should appear once per STYLE, not once per file.
+    std::sort(out.begin(), out.end(), [](const FontFace& a, const FontFace& b) {
+        if (a.family != b.family) return a.family < b.family;
+        return a.style < b.style;
+    });
+    out.erase(std::unique(out.begin(), out.end(),
+                           [](const FontFace& a, const FontFace& b) {
+                               return a.family == b.family && a.style == b.style;
+                           }),
+              out.end());
+    return out;
+}
+
 FontMetrics FreetypeFontProvider::metrics(FontHandle handle) {
     if (handle >= impl_->faces.size()) return impl_->faces[0].metrics;
     return impl_->faces[handle].metrics;