openscad-cpp-evaluator 0.33.0__tar.gz → 0.34.0__tar.gz

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/CLAUDE.md

@@ -512,6 +512,9 @@ grep for `ponytail:`.
   `Evaluator::evaluate()` also takes an optional `viewportParams` map (added after a test-suite
   parity review found it missing entirely): seeds arbitrary `$`-prefixed entries into `ctx.dyn`
   (e.g. `$vpt`/`$vpr`/`$vpd`/`$vpf` from a GUI host's current camera, or `$t` for animation time)
+  — note `EvalContext::makeRoot` also seeds `$preview` to **`false`**, always: there is no preview
+  mode here, and leaving it undef made the common `$preview ? cheap : real` idiom take the cheap
+  branch by accident while warning about an unknown variable
   before evaluation starts, via a direct `ctx.dyn` write that deliberately never touches
   `ctx.dynExplicit` — lets a caller tell "the script itself assigned this `$`-var"
   (`dynExplicit`) apart from "merely present because the caller seeded it" after `evaluate()`
@@ -558,13 +561,49 @@ 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”).
-- `src/builtins/topology.cpp` — `hull()`/`minkowski()`. Both splice their children transparently in
+- `src/builtins/dxf_dim.cpp` — `dxf_dim()`/`dxf_cross()`, which read a measurement out of a DXF file
+  rather than out of the model. Ported from the reference's `io/dxfdim.cc` plus the DIMENSION/LINE
+  half of `io/DxfData.cc`: `dxf_dim()` returns the first matching DIMENSION's value by its type
+  (`70 & 7` — 0 rotated, 1 aligned, 2 angular, 3/4 diameter/radius, 6 ordinate; type 5 is
+  unsupported there too), `dxf_cross()` intersects the first two LINE entities. Note the reference's
+  own coordinate quirk, reproduced here: groups 11/12/16 (and 21/22/26) are scaled but NOT
+  origin-shifted, being extents rather than positions.
+
+  Deliberately its own group-code walk rather than sharing `src/import/dxf_import.cpp`'s: that one
+  produces closed contours, and these need the DIMENSION entities' seven coordinate slots and the
+  raw LINE endpoints, neither of which a contour list keeps. One divergence: `dxf_cross()` takes the
+  first two LINEs, where the reference walks every 2-point path — for a real cross (two strokes
+  meeting in the middle, not at their endpoints) that is the same set.
+
+- `src/csg_generate.cpp` — `Evaluator::applyDimensionRules`, run centrally just before every node's
+  `GenerateFn` (and once more over the top-level list, which is an implicit union). Mirrors the
+  reference's `isValidDim` + `collectChildren2D`/`collectChildren3D`: a node's dimension is fixed by
+  its first non-background, non-empty child, and every child of the other dimension is dropped with
+  `Mixing 2D and 3D objects is not supported` followed by `Ignoring {N}D child object for {M}D
+  operation`. `linear_extrude`/`rotate_extrude`/`offset` are always-2D and `projection` always-3D, so
+  they skip the "mixing" line and emit only the second; `roof()` emits neither, matching the
+  reference. Background (`%`) children are exempt.
+
+  Doing this centrally is also what keeps `generateCsg` safe: it builds ONE result and switches on
+  whether it holds a `body` or a `section`, so a group that changed dimension part-way dereferenced
+  the empty optional -- `union() { cube(1); square(4); }` took the process down with "mutex lock
+  failed: Invalid argument". Filtering before dispatch means no `GenerateFn` ever sees a mixed group.
+  All 25 module/shape combinations were diffed against OpenSCAD 2026.02.01 warning for warning, with
+  the surviving geometry compared by STL volume.
+
+- `src/builtins/topology.cpp` — `hull()`/`minkowski()`/`fill()`. All three splice their children transparently in
   the CSG tree exactly like union/difference/intersection (resolve just evaluates them for the
   side effect); `hull()` picks an all-3D (`Manifold::Hull`) or all-2D (`CrossSection::Hull`) hull of
   the *foreground* (role-split) children, falling back to sections only when no child has a body;
   `minkowski()` only ever operates on 3D bodies (a 2D sibling among the foreground children is
   silently ignored, matching the reference exactly — no 2D `minkowski_sum` fallback the way hull
-  has one). Both pass background/highlight/show_only bodies through untouched.
+  has one). All pass background/highlight/show_only bodies through untouched. `fill()` is 2D-only
+  (a 3D foreground child draws the reference's own `fill() not yet implemented for 3D` warning and
+  contributes nothing): it unions the foreground sections, keeps only the outlines with positive
+  signed area — outer boundaries, since Manifold winds a hole clockwise — and re-unions those,
+  which matters because two outers can overlap once the holes between them are gone. Ported from
+  the reference's `applyFill2D`, and checked shape-for-shape against OpenSCAD 2026.02.01 by
+  extruding and comparing STL volumes.
 - `src/builtins/extrude.cpp` — `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`. All three
   union every 2D child into one `CrossSection` via `toCrossSection` first. `rotate_extrude`'s
   segment count can't be resolved until generate time (it depends on the merged children's bounds,

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -330,6 +330,12 @@ public:
     // free function, same reasoning as tagGenerated()/builtinChildren().
     void warn(const std::string& message, const oscad::Position* position);
 
+    // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
+    // before its GenerateFn runs -- see csg_generate.cpp.
+    void applyDimensionRules(CSGNode& node);
+    // ruleValue is a DimRule; the enum is file-local to csg_generate.cpp.
+    void applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue);
+
     // Apply `!`: replace the whole tree with the first show_only
     // subtree, discarding its ancestors and every sibling. See its
     // definition for why this cannot be done by tagging bodies.

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/CMakeLists.txt

@@ -29,6 +29,7 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/call_args.cpp
   builtins/segments.cpp
   builtins/registry.cpp
+  builtins/dxf_dim.cpp
   builtins/primitives_2d.cpp
   builtins/primitives_3d.cpp
   builtins/transforms.cpp

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/builtins/builtins.hpp

@@ -160,6 +160,15 @@ CSGParams resolveHull(Evaluator& ev, const oscad::ModularCall& node, EvalContext
 std::vector<ColoredBody> generateHull(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
+// dxf_dim()/dxf_cross() -- read a dimension or a cross's centre out of a
+// DXF file. Functions, not modules; dispatched from evalBuiltinFunction.
+Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+
+CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams& params,
+                                       const std::vector<std::unique_ptr<CSGNode>>& children,
+                                       const oscad::ASTNode& node);
 CSGParams resolveMinkowski(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateMinkowski(Evaluator& ev, const CSGParams& params,
                                             const std::vector<std::unique_ptr<CSGNode>>& children,

openscad_cpp_evaluator-0.34.0/src/builtins/dxf_dim.cpp

@@ -0,0 +1,221 @@
+#include "builtins.hpp"
+
+#include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include <cmath>
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+
+namespace oscadeval {
+
+// dxf_dim() / dxf_cross() -- read a measurement straight out of a DXF file
+// rather than out of the model. Ported from the reference's io/dxfdim.cc
+// plus the DIMENSION/LINE half of io/DxfData.cc.
+//
+// These share the group-code walk with src/import/dxf_import.cpp but not its
+// output: that one only cares about closed contours, while these two need
+// the DIMENSION entities' seven coordinate slots and the raw LINE endpoints,
+// neither of which a contour list keeps.
+
+namespace {
+
+struct Entity {
+    std::string type;                  // "DIMENSION", "LINE", ...
+    std::string layer;
+    std::string name;                  // group 1: DIMENSION's text override
+    int dimType = 0;                   // group 70
+    double angle = 0.0;                // group 50
+    double coords[7][2] = {};          // groups 10-16 / 20-26
+    std::vector<double> xverts, yverts; // groups 10/11 and 20/21, in order
+};
+
+std::string trimmed(const std::string& s) {
+    const size_t b = s.find_first_not_of(" \t\r\n");
+    if (b == std::string::npos) return "";
+    return s.substr(b, s.find_last_not_of(" \t\r\n") - b + 1);
+}
+
+// One entity per group-0 marker. Coordinates carry the origin shift and
+// scale the reference applies while parsing, with its own exception: groups
+// 11, 12 and 16 (and their 21/22/26 partners) are scaled but NOT shifted,
+// since they are extents rather than positions.
+std::vector<Entity> readEntities(const std::string& path, double xorigin, double yorigin, double scale) {
+    std::ifstream in(path);
+    std::vector<Entity> out;
+    if (!in) return out;
+
+    std::string codeLine, dataLine;
+    Entity cur;
+    bool started = false;
+    while (std::getline(in, codeLine) && std::getline(in, dataLine)) {
+        const std::string codeStr = trimmed(codeLine);
+        const std::string data = trimmed(dataLine);
+        if (codeStr.empty()) continue;
+        int code = 0;
+        try {
+            code = std::stoi(codeStr);
+        } catch (...) {
+            break;
+        }
+        const auto num = [&]() -> double {
+            try {
+                return std::stod(data);
+            } catch (...) {
+                return 0.0;
+            }
+        };
+
+        if (code == 0) {
+            if (started) out.push_back(cur);
+            cur = Entity{};
+            cur.type = data;
+            started = true;
+            continue;
+        }
+        if (!started) continue;
+
+        if (code >= 10 && code <= 16) {
+            cur.coords[code - 10][0] =
+                (code == 11 || code == 12 || code == 16) ? num() * scale : (num() - xorigin) * scale;
+        } else if (code >= 20 && code <= 26) {
+            cur.coords[code - 20][1] =
+                (code == 21 || code == 22 || code == 26) ? num() * scale : (num() - yorigin) * scale;
+        }
+        switch (code) {
+            case 1: cur.name = data; break;
+            case 8: cur.layer = data; break;
+            case 10:
+            case 11: cur.xverts.push_back((num() - xorigin) * scale); break;
+            case 20:
+            case 21: cur.yverts.push_back((num() - yorigin) * scale); break;
+            case 50: cur.angle = num(); break;
+            case 70:
+                try {
+                    cur.dimType = std::stoi(data);
+                } catch (...) {
+                }
+                break;
+            default: break;
+        }
+    }
+    if (started) out.push_back(cur);
+    return out;
+}
+
+double deg(double r) { return r * 180.0 / 3.14159265358979323846; }
+double rad(double d) { return d * 3.14159265358979323846 / 180.0; }
+
+struct CommonArgs {
+    std::string path;
+    std::string rawFile;
+    std::string layer;
+    double xorigin = 0.0, yorigin = 0.0, scale = 1.0;
+};
+
+CommonArgs commonArgs(const CallArgs& args, const oscad::ASTNode& node) {
+    CommonArgs c;
+    const Value fileArg = getArg(args, 0, "file", Value{});
+    c.rawFile = std::holds_alternative<std::string>(fileArg) ? std::get<std::string>(fileArg) : fmtValue(fileArg);
+    c.path = resolveFilePath(fileArg, node);
+    const Value layerArg = getArg(args, std::nullopt, "layer", Value{});
+    if (const std::string* s = std::get_if<std::string>(&layerArg)) c.layer = *s;
+    const Value originArg = getArg(args, std::nullopt, "origin", Value{});
+    if (const ListPtr* l = std::get_if<ListPtr>(&originArg); l && *l && (*l)->items.size() >= 2) {
+        c.xorigin = toDoubleLenient((*l)->items[0]);
+        c.yorigin = toDoubleLenient((*l)->items[1]);
+    }
+    const Value scaleArg = getArg(args, std::nullopt, "scale", Value{1.0});
+    if (std::holds_alternative<double>(scaleArg)) c.scale = std::get<double>(scaleArg);
+    return c;
+}
+
+} // namespace
+
+Value builtinDxfDim(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node) {
+    const CommonArgs c = commonArgs(args, node);
+    const Value nameArg = getArg(args, std::nullopt, "name", Value{});
+    const std::string name = std::holds_alternative<std::string>(nameArg) ? std::get<std::string>(nameArg) : "";
+
+    if (!std::filesystem::exists(c.path)) {
+        ev.warn("Can't open DXF file '" + c.rawFile + "'!", &node.position());
+        return Value{};
+    }
+    for (const Entity& e : readEntities(c.path, c.xorigin, c.yorigin, c.scale)) {
+        if (e.type != "DIMENSION") continue;
+        if (!c.layer.empty() && c.layer != e.layer) continue;
+        if (!name.empty() && e.name != name) continue;
+
+        const int type = e.dimType & 7;
+        if (type == 0) {   // rotated, horizontal or vertical
+            const double x = e.coords[4][0] - e.coords[3][0];
+            const double y = e.coords[4][1] - e.coords[3][1];
+            return Value{std::fabs(x * std::cos(rad(e.angle)) + y * std::sin(rad(e.angle)))};
+        }
+        if (type == 1) {   // aligned
+            const double x = e.coords[4][0] - e.coords[3][0];
+            const double y = e.coords[4][1] - e.coords[3][1];
+            return Value{std::sqrt(x * x + y * y)};
+        }
+        if (type == 2) {   // angular
+            const double a1 = deg(std::atan2(e.coords[0][0] - e.coords[5][0], e.coords[0][1] - e.coords[5][1]));
+            const double a2 = deg(std::atan2(e.coords[4][0] - e.coords[3][0], e.coords[4][1] - e.coords[3][1]));
+            return Value{std::fabs(a1 - a2)};
+        }
+        if (type == 3 || type == 4) {   // diameter or radius
+            const double x = e.coords[5][0] - e.coords[0][0];
+            const double y = e.coords[5][1] - e.coords[0][1];
+            return Value{std::sqrt(x * x + y * y)};
+        }
+        if (type == 6) {   // ordinate
+            return Value{(e.dimType & 64) ? e.coords[3][0] : e.coords[3][1]};
+        }
+        // type 5 (angular 3-point) falls through, as in the reference.
+        ev.warn("Dimension '" + name + "' in '" + c.rawFile + "', layer '" + c.layer + "' has unsupported type!",
+                &node.position());
+        return Value{};
+    }
+    ev.warn("Can't find dimension '" + name + "' in '" + c.rawFile + "', layer '" + c.layer + "'!",
+            &node.position());
+    return Value{};
+}
+
+Value builtinDxfCross(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node) {
+    const CommonArgs c = commonArgs(args, node);
+    if (!std::filesystem::exists(c.path)) {
+        ev.warn("Can't open DXF file '" + c.rawFile + "'!", &node.position());
+        return Value{};
+    }
+
+    // The first two LINEs on the layer are taken to be the cross. The
+    // reference walks every 2-point path instead, which for a real cross is
+    // the same set: its two strokes meet in the middle rather than at their
+    // endpoints, so neither gets joined into a longer path.
+    double p[4][2];
+    int found = 0;
+    for (const Entity& e : readEntities(c.path, c.xorigin, c.yorigin, c.scale)) {
+        if (e.type != "LINE") continue;
+        if (!c.layer.empty() && c.layer != e.layer) continue;
+        if (e.xverts.size() < 2 || e.yverts.size() < 2) continue;
+        p[found][0] = e.xverts[0];
+        p[found][1] = e.yverts[0];
+        ++found;
+        p[found][0] = e.xverts[1];
+        p[found][1] = e.yverts[1];
+        ++found;
+        if (found == 4) {
+            const double x1 = p[0][0], y1 = p[0][1], x2 = p[1][0], y2 = p[1][1];
+            const double x3 = p[2][0], y3 = p[2][1], x4 = p[3][0], y4 = p[3][1];
+            const double dem = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
+            if (dem == 0.0) break;   // parallel: no cross, same as the reference
+            const double ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / dem;
+            std::vector<Value> xy{Value{x1 + ua * (x2 - x1)}, Value{y1 + ua * (y2 - y1)}};
+            return Value{std::make_shared<const ValueList>(ValueList{std::move(xy)})};
+        }
+    }
+    ev.warn("Can't find cross in '" + c.rawFile + "', layer '" + c.layer + "'!", &node.position());
+    return Value{};
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/builtins/function_builtins.cpp

@@ -1,5 +1,7 @@
 #include "openscad_cpp_evaluator/function_builtins.hpp"
 
+#include "builtins.hpp"   // builtinDxfDim/builtinDxfCross
+
 #include "openscad_cpp_evaluator/dispatch.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 #include "openscad_cpp_evaluator/segments.hpp"
@@ -447,7 +449,7 @@ bool isBuiltinFunctionName(const std::string& name) {
         "acos", "atan", "atan2", "max", "min", "pow", "norm", "cross", "rands", "concat", "len", "str",
         "chr", "ord", "is_undef", "is_num", "is_bool", "is_string", "is_list", "is_function", "is_object",
         "search", "lookup", "has_key", "version", "version_num", "parent_module",
-        "object", "textmetrics", "fontmetrics",
+        "object", "textmetrics", "fontmetrics", "dxf_dim", "dxf_cross",
     };
     return names.count(name) > 0;
 }
@@ -514,7 +516,7 @@ enum class BuiltinFnId {
     TextMetrics, FontMetrics, Abs, Sign, Ceil, Floor, Round, Sqrt, Ln, Log, Exp, Sin, Cos, Tan,
     Asin, Acos, Atan, Atan2, Max, Min, Pow, Norm, Cross, Rands, Concat, Len, Str, Chr, Ord,
     IsUndef, IsNum, IsBool, IsString, IsList, IsFunction, IsObject, Search, Lookup, HasKey,
-    Version, VersionNum, ParentModule,
+    Version, VersionNum, ParentModule, DxfDim, DxfCross,
 };
 
 const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
@@ -536,6 +538,7 @@ const std::unordered_map<std::string, BuiltinFnId>& builtinFnIds() {
         {"lookup", BuiltinFnId::Lookup}, {"has_key", BuiltinFnId::HasKey},
         {"version", BuiltinFnId::Version}, {"version_num", BuiltinFnId::VersionNum},
         {"parent_module", BuiltinFnId::ParentModule},
+        {"dxf_dim", BuiltinFnId::DxfDim}, {"dxf_cross", BuiltinFnId::DxfCross},
     };
     return ids;
 }
@@ -949,6 +952,8 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
             if (!v || (v->size() != 2 && v->size() != 3)) return Value{};
             return Value{(*v)[0] * 10000.0 + (*v)[1] * 100.0 + (v->size() == 3 ? (*v)[2] : 0.0)};
         }
+        case BuiltinFnId::DxfDim: return builtinDxfDim(ev, args, node);
+        case BuiltinFnId::DxfCross: return builtinDxfCross(ev, args, node);
         case BuiltinFnId::ParentModule: {
             // Defaults to 1, not 0, when called with no argument at all --
             // and an index past the end of the stack is a warning, not a

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/builtins/registry.cpp

@@ -34,6 +34,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"rotate_extrude", &resolveRotateExtrude},
         {"projection", &resolveProjection},
         {"roof", &resolveRoof},
+        {"fill", &resolveFill},
         {"offset", &resolveOffset},
         {"surface", &resolveSurface},
         {"text", &resolveText},
@@ -72,6 +73,7 @@ const std::unordered_map<std::string_view, GenerateFn>& generateDispatch() {
         {"rotate_extrude", &generateRotateExtrude},
         {"projection", &generateProjection},
         {"roof", &generateRoof},
+        {"fill", &generateFill},
         {"offset", &generateOffset},
         {"surface", &generateSurface},
         {"text", &generateText},
@@ -116,6 +118,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"rotate_extrude", {"angle", "start", "convexity"}},
         {"projection", {"cut", "convexity"}},
         {"roof", {"method", "convexity"}},
+        {"fill", {}},
         {"offset", {"r", "delta", "chamfer"}},
         {"surface", {"file", "center", "convexity", "invert"}},
         {"text", {"text", "size", "font", "direction", "language", "script", "halign", "valign", "spacing"}},

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/builtins/topology.cpp

@@ -67,6 +67,76 @@ std::vector<ColoredBody> generateHull(Evaluator&, const CSGParams&, const std::v
     return result;
 }
 
+// fill() -- 2D only: union the children, then discard every hole, keeping
+// just the outer boundaries. Ported from the reference's applyFill2D: union
+// the children, keep only the *positive* outlines, then re-union those (two
+// outers can overlap once the holes between them are gone, and the result
+// has to come back as one sanitized region rather than a pile of loops).
+//
+// A 3D child gets the reference's own "not yet implemented for 3D" warning
+// and contributes nothing.
+
+CSGParams resolveFill(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    (void)args;
+    ev.evalChildren(node.children, effCtx);
+    return CSGParams{};
+}
+
+namespace {
+
+// Shoelace. Manifold orients an outer contour counter-clockwise (positive
+// area) and a hole clockwise, so the sign is the whole test.
+double signedArea(const manifold::SimplePolygon& poly) {
+    double a = 0.0;
+    for (size_t i = 0, n = poly.size(); i < n; ++i) {
+        const auto& p = poly[i];
+        const auto& q = poly[(i + 1) % n];
+        a += static_cast<double>(p.x) * q.y - static_cast<double>(q.x) * p.y;
+    }
+    return a / 2.0;
+}
+
+} // namespace
+
+std::vector<ColoredBody> generateFill(Evaluator& ev, const CSGParams&,
+                                       const std::vector<std::unique_ptr<CSGNode>>& children,
+                                       const oscad::ASTNode& node) {
+    const std::vector<ColoredBody> bodies = flattenCsgTree(children);
+    if (bodies.empty()) return {};
+    const RoleSplit split = splitByRole(bodies);
+
+    std::optional<ColoredBody> filled;
+    if (!split.foreground.empty()) {
+        for (const ColoredBody& c : split.foreground) {
+            if (c.body) {
+                ev.warn("fill() not yet implemented for 3D", &node.position());
+                break;
+            }
+        }
+        if (const std::optional<manifold::CrossSection> cs = toCrossSection(split.foreground)) {
+            manifold::Polygons outers;
+            for (const manifold::SimplePolygon& loop : cs->ToPolygons()) {
+                if (signedArea(loop) > 0.0) outers.push_back(loop);
+            }
+            if (!outers.empty()) {
+                ColoredBody cb;
+                cb.section = manifold::CrossSection(outers, manifold::CrossSection::FillRule::Positive);
+                cb.color = split.foreground.front().color;
+                filled = std::move(cb);
+            }
+        }
+    }
+
+    std::vector<ColoredBody> result;
+    if (filled) result.push_back(std::move(*filled));
+    result.insert(result.end(), split.background.begin(), split.background.end());
+    result.insert(result.end(), split.highlight.begin(), split.highlight.end());
+    result.insert(result.end(), split.showOnly.begin(), split.showOnly.end());
+    result.insert(result.end(), split.displayOnly.begin(), split.displayOnly.end());
+    return result;
+}
+
 CSGParams resolveMinkowski(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     (void)args;

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/csg_generate.cpp

@@ -62,6 +62,8 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             for (const std::unique_ptr<CSGNode>& c : node.children) childPtrs.push_back(c.get());
             generateTreeImpl(childPtrs);
 
+            applyDimensionRules(node);
+
             auto it = dispatch.find(node.kind);
             if (node.isBuiltin && it != dispatch.end()) {
                 // Resolve captured which user-level call reached this node;
@@ -90,11 +92,115 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
     return topLevelBodies;
 }
 
+
+namespace {
+
+// How a node treats children of the "wrong" dimension. Read off OpenSCAD
+// 2026.02.01 module by module rather than inferred: essentially everything
+// is Group (the reference routes it through applyToChildren, which calls
+// isValidDim and then collectChildren2D/3D), with four exceptions.
+enum class DimRule {
+    Group,   // dimension comes from the first real child; mismatches warn twice
+    Only2D,  // always 2D input; a 3D child is dropped with one warning
+    Only3D,  // always 3D input; a 2D child is dropped with one warning
+    None,    // no dimension diagnostics at all
+};
+
+DimRule dimRuleFor(const std::string& kind) {
+    if (kind == "linear_extrude" || kind == "rotate_extrude" || kind == "offset") return DimRule::Only2D;
+    if (kind == "projection") return DimRule::Only3D;
+    // roof() warns for neither in the reference, so neither do we.
+    if (kind == "roof") return DimRule::None;
+    return DimRule::Group;
+}
+
+bool isEmptyBody(const ColoredBody& b) {
+    if (b.body) return b.body->NumTri() == 0;
+    if (b.section) return b.section->IsEmpty();
+    return true;
+}
+
+// 3 for a solid, 2 for a section, 0 for "no geometry at all" (which never
+// takes part in the dimension decision).
+int dimensionOf(const ColoredBody& b) {
+    if (b.body) return 3;
+    if (b.section) return 2;
+    return 0;
+}
+
+} // namespace
+
+// Drops children of the wrong dimension, with the reference's own two
+// warnings. This is not only about diagnostics: generateCsg builds one
+// result and switches on whether it holds a body or a section, so a group
+// that changed dimension part-way dereferenced the empty optional and took
+// the process down ("mutex lock failed" from the garbage read). Filtering
+// here means no downstream generate ever sees a mixed group.
+//
+// Background (%) children are exempt, matching isValidDim's own
+// isBackground() skip -- a ghost of the other dimension is not an error.
+void Evaluator::applyDimensionRules(CSGNode& node) {
+    const DimRule rule = dimRuleFor(node.kind);
+    if (rule == DimRule::None) return;
+    std::vector<CSGNode*> kids;
+    kids.reserve(node.children.size());
+    for (const std::unique_ptr<CSGNode>& c : node.children) kids.push_back(c.get());
+    applyDimensionRulesTo(kids, static_cast<int>(rule));
+}
+
+// The top level is an implicit union, and the reference treats it as one for
+// this too: `square(4); cube(1);` warns and keeps only the square.
+void Evaluator::applyDimensionRulesTo(const std::vector<CSGNode*>& children, int ruleValue) {
+    const DimRule rule = static_cast<DimRule>(ruleValue);
+    int target = rule == DimRule::Only2D ? 2 : rule == DimRule::Only3D ? 3 : 0;
+    bool warnedMixing = false;
+
+    for (CSGNode* child : children) {
+        if (!child) continue;
+        std::vector<ColoredBody> kept;
+        kept.reserve(child->bodies.size());
+        for (ColoredBody& b : child->bodies) {
+            const int dim = dimensionOf(b);
+            if (b.role == BodyRole::Background || dim == 0 || isEmptyBody(b)) {
+                kept.push_back(std::move(b));
+                continue;
+            }
+            if (target == 0) {
+                target = dim;            // first real child fixes the dimension
+                kept.push_back(std::move(b));
+                continue;
+            }
+            if (dim == target) {
+                kept.push_back(std::move(b));
+                continue;
+            }
+            const oscad::Position* pos = child->node ? &child->node->position() : nullptr;
+            if (rule == DimRule::Group && !warnedMixing) {
+                warn("Mixing 2D and 3D objects is not supported", pos);
+                warnedMixing = true;
+            }
+            warn(std::string("Ignoring ") + (dim == 3 ? "3D" : "2D") + " child object for " +
+                     (target == 3 ? "3D" : "2D") + " operation",
+                 pos);
+            // dropped
+        }
+        child->bodies = std::move(kept);
+    }
+}
+
 std::vector<ColoredBody> Evaluator::generateTree(const std::vector<std::unique_ptr<CSGNode>>& tree) {
     std::vector<CSGNode*> ptrs;
     ptrs.reserve(tree.size());
     for (const std::unique_ptr<CSGNode>& n : tree) ptrs.push_back(n.get());
-    return generateTreeImpl(ptrs);
+    std::vector<ColoredBody> bodies = generateTreeImpl(ptrs);
+    // The top level is an implicit union; give it the same Group treatment
+    // every other group node gets, then re-collect what survived.
+    applyDimensionRulesTo(ptrs, static_cast<int>(DimRule::Group));
+    bodies.clear();
+    for (CSGNode* n : ptrs) {
+        for (const ColoredBody& b : n->bodies) bodies.push_back(b);
+    }
+    return bodies;
 }
 
 std::vector<ColoredBody> Evaluator::generatePartialTree() {

{openscad_cpp_evaluator-0.33.0 → openscad_cpp_evaluator-0.34.0}/src/eval_context.cpp

@@ -15,6 +15,12 @@ EvalContext EvalContext::makeRoot(const oscad::Scope* rootScope) {
     ctx.dyn->set("$fs", Value{2.0});
     ctx.dyn->set("$t", Value{0.0});
     ctx.dyn->set("$parent_modules", Value{0.0});
+    // Always false: there is no preview mode here, every render is a full
+    // CSG render. The variable still has to EXIST, though -- a script that
+    // branches on it (the `$preview ? cheap : real` idiom) would otherwise
+    // see undef, take the falsy branch by accident rather than by rule, and
+    // warn about an unknown variable while doing it.
+    ctx.dyn->set("$preview", Value{false});
     ctx.let_ = TrailView<Value>::makeRoot();
     ctx.dynPositions = TrailView<const oscad::Position*>::makeRoot();
     ctx.childrenNodes = std::make_shared<const ChildrenNodeList>();