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

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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,21 @@ 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.
 
+**`text()` takes `font` positionally too — and NOTHING after it.** `text(text, size, font)` is the
+positional set; `halign`/`valign`/`spacing`/`direction`/`language`/`script` are name-only, because
+that is what the 2026.02.01 binary does: `text("Hi", 10, "F", "center")` is not centred there while
+`halign="center"` is, measured by bounding box. So **`text()` and `textmetrics()` genuinely differ**
+— the latter takes all nine positionally — and neither can be assumed from the other. `font` being
+name-only made `text("Hi", 10, "Liberation Sans:style=Bold")` silently draw the default face.
+
+**`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
@@ -953,7 +977,15 @@ grep for `ponytail:`.
   restating the list, because three hand-written copies had already drifted far enough that `.off`
   could be written by neither the GUI nor the CLI while every test passed.
   Colour is carried by 3MF, AMF, OBJ (companion `.mtl`), PLY, VRML and X3D; STL and OFF compose
-  every body into one solid and store geometry only. **AMF** puts colour on the `<volume>` rather
+  every body into one solid and store geometry only.
+  **`ExportOptions::splitColors` picks what the file is FOR**, and is the axis worth asking a user
+  about rather than "should parts be separate": on (the default) writes one object per colour, which
+  is what a **multi-material** print wants — each colour is something the slicer assigns to a
+  filament. Off is a **single-material** print: everything unions into one welded solid, so touching
+  colour regions lose the coincident faces that stacking per-colour objects would leave, and the
+  per-triangle colour is dropped because such a print has no use for it. Implemented by forcing
+  `splitBodiesForExport`'s `allSame` branch, which already unions rather than concatenates —
+  concatenating the per-colour objects instead would have left the seam. **AMF** puts colour on the `<volume>` rather
   than the face, so an object whose triangles are not all one colour is written as one volume per
   colour — per-triangle `<color>` is legal in the spec but poorly supported by the slicers that are
   the audience for it.

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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.13.0 → openscad_cpp_evaluator-1.15.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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"
@@ -403,7 +404,8 @@ void applyPdfOptions(const nb::dict& d, oscadeval::ExportPdfOptions& pdf) {
 }
 
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers, bool splitComponents, bool svgFill, const std::string& svgFillColor,
+                        bool stripSlivers, bool splitComponents, bool splitColors, bool svgFill,
+                        const std::string& svgFillColor,
                         bool svgStroke, const std::string& svgStrokeColor, double svgStrokeWidth,
                         nb::object pdfOptions) {
     oscadeval::ExportPdfOptions pdf;
@@ -417,6 +419,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
         opts.splitComponents = splitComponents;
+        opts.splitColors = splitColors;
         opts.svg.fill = svgFill;
         opts.svg.fillColor = svgFillColor;
         opts.svg.stroke = svgStroke;
@@ -849,7 +852,8 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
 
     m.def("export_model", &exportModelPy, nb::arg("path"), nb::arg("geometry"), nb::arg("format") = std::string(),
           nb::arg("ascii_stl") = false, nb::arg("strip_slivers") = true,
-          nb::arg("split_components") = false, nb::arg("svg_fill") = false,
+          nb::arg("split_components") = false, nb::arg("split_colors") = true,
+          nb::arg("svg_fill") = false,
           nb::arg("svg_fill_color") = std::string("white"), nb::arg("svg_stroke") = true,
           nb::arg("svg_stroke_color") = std::string("black"), nb::arg("svg_stroke_width") = 0.35,
           nb::arg("pdf_options") = nb::none(),
@@ -860,6 +864,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "`split_components` gives every disconnected piece its own object in the multi-object formats "
           "(3MF, AMF, OBJ, PLY, VRML, X3D). Off by default, matching OpenSCAD, which writes one object "
           "per colour however many pieces it is in.\n\n"
+          "`split_colors` (on by default) writes one object per colour -- what a MULTI-MATERIAL print "
+          "wants, each colour being something the slicer assigns to a filament. Turn it off for a "
+          "single-material print: everything welds into one solid, with no seams between colour "
+          "regions and no per-triangle colour it has no use for.\n\n"
           "The svg_* arguments are OpenSCAD's -O export-svg/... set and apply to .svg only. "
           "svg_stroke/svg_stroke_width also pad the page, so they are not purely cosmetic. An .svg "
           "export needs an all-2D model and raises otherwise, as OpenSCAD does.\n\n"
@@ -869,6 +877,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.15.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.13.0 → openscad_cpp_evaluator-1.15.0}/include/openscad_cpp_evaluator/export.hpp

@@ -53,7 +53,8 @@ struct ExportObject {
 // 1-based index is appended to `openParts` for the caller to warn about.
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies,
                                                 std::vector<int>* openParts = nullptr,
-                                                bool splitComponents = false);
+                                                bool splitComponents = false,
+                                                bool splitColors = true);
 
 // Writes a binary STL: composes every body's mesh into one solid (bodies
 // with no `.body` -- 2D-only sections -- or an empty Manifold are
@@ -236,6 +237,12 @@ struct ExportOptions {
     // pieces it is in; see that function's own comment for why the default
     // moved here.
     bool splitComponents = false;
+    // Rule 2 of splitBodiesForExport: one object per colour. That is what
+    // a MULTI-MATERIAL print wants -- each colour becomes something the
+    // slicer assigns to a filament. Turn it off for a single-material
+    // print, which wants one welded solid instead: no seams between
+    // colour regions, and no per-triangle colour it has no use for.
+    bool splitColors = true;
     // .svg only.
     ExportSvgOptions svg;
     // .pdf only.

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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.13.0 → openscad_cpp_evaluator-1.15.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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",
 ]
 
 
@@ -293,6 +293,7 @@ def strip_slivers(verts, tris):
 
 def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
                  strip_slivers: bool = True, split_components: bool = False,
+                 split_colors: bool = True,
                  svg_fill: bool = False, svg_fill_color: str = "white",
                  svg_stroke: bool = True, svg_stroke_color: str = "black",
                  svg_stroke_width: float = 0.35, pdf_options: dict | None = None) -> list:
@@ -316,6 +317,12 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     `split_components` gives every disconnected piece its own object in the
     multi-object formats. Off by default, which is what OpenSCAD writes.
 
+    `split_colors` (on by default) writes one object per colour -- what a
+    MULTI-MATERIAL print wants, each colour being something the slicer
+    assigns to a filament. Turn it off for a single-material print:
+    everything welds into one solid, with no seams between colour regions
+    and no per-triangle colour it has no use for.
+
     The `svg_*` arguments are OpenSCAD's `-O export-svg/...` set and apply
     to `.svg` only, which writes a 2D model at 1:1 in millimetres.
     `svg_stroke`/`svg_stroke_width` also pad the page, so they are not
@@ -335,13 +342,30 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
     """
     try:
         return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
-                                       split_components, svg_fill, svg_fill_color,
+                                       split_components, split_colors, svg_fill, svg_fill_color,
                                        svg_stroke, svg_stroke_color, svg_stroke_width,
                                        pdf_options))
     except Exception as e:
         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.13.0 → openscad_cpp_evaluator-1.15.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.13.0 → openscad_cpp_evaluator-1.15.0}/src/builtins/text.cpp

@@ -34,7 +34,18 @@ CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext
     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}));
-    const std::string fontSpec = asStringOr(getArg(args, std::nullopt, "font", Value{std::string("")}), "");
+    // 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
+    // positional form matches the named one exactly.
+    //
+    // Only font. halign/valign/spacing/direction/language/script stay
+    // name-only, because the same measurement shows the reference
+    // ignoring them positionally: `text("Hi", 10, "F", "center")` is NOT
+    // centred there, while halign="center" is. text() and textmetrics()
+    // genuinely differ here -- textmetrics takes all nine positionally --
+    // so neither can be assumed from the other.
+    const std::string fontSpec = asStringOr(getArg(args, 2, "font", Value{std::string("")}), "");
     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}));

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.0}/src/export.cpp

@@ -421,7 +421,7 @@ std::vector<std::array<float, 4>> carryTriColors(const std::vector<std::array<fl
 } // namespace
 
 std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& bodies, std::vector<int>* openParts,
-                                                bool splitComponents) {
+                                                bool splitComponents, bool splitColors) {
     struct Solid {
         manifold::Manifold man;
         std::optional<std::array<float, 4>> color;
@@ -484,7 +484,15 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             if (k.hasColor) k.color = *solids[i].color;
             keys.push_back(k);
         }
-        const bool allSame = std::all_of(keys.begin(), keys.end(), [&](const ColorKey& k) { return k == keys[0]; });
+        // Splitting by colour is for a MULTI-MATERIAL print, where each
+        // colour becomes an object the slicer assigns to a filament. A
+        // single-material print wants the opposite: one welded solid, with
+        // no seams between colour regions for the slicer to treat as
+        // 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 ||
+            std::all_of(keys.begin(), keys.end(), [&](const ColorKey& k) { return k == keys[0]; });
 
         if (allSame) {
             // The common case by far, and it needs no per-body subtraction
@@ -496,7 +504,10 @@ std::vector<ExportObject> splitBodiesForExport(const std::vector<ColoredBody>& b
             Claimed c;
             c.man = addAll(parts);
             c.color = solids[0].color;
-            c.triColors = solids[0].triColors;
+            // Per-triangle colour cannot survive a weld across colours --
+            // the union rebuilds the surface -- and a single-material
+            // print has no use for it anyway.
+            c.triColors = splitColors ? solids[0].triColors : std::vector<std::array<float, 4>>{};
             c.sourceTris = solids[0].tris;
             c.key = keys[0];
             claimedGroups.push_back(std::move(c));
@@ -1507,7 +1518,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         // its own -- that is what the file contains.
         for (std::string& w : checkExportBodies(bodies)) warnings.push_back(std::move(w));
         std::vector<int> openParts;
-        const std::vector<ExportObject> objects = splitBodiesForExport(bodies, &openParts, opts.splitComponents);
+        const std::vector<ExportObject> objects =
+            splitBodiesForExport(bodies, &openParts, opts.splitComponents, opts.splitColors);
         reportOpen(openParts);
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {

{openscad_cpp_evaluator-1.13.0 → openscad_cpp_evaluator-1.15.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;