openscad-cpp-evaluator 1.42.0__tar.gz → 1.44.0__tar.gz

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/CLAUDE.md

@@ -63,7 +63,7 @@ plus gating the silent `is_undef` probe on the call actually resolving to the bu
 CSG-tree shape like union/difference/intersection, role-split via the shared `splitByRole`),
 `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`, and `roof()`; and (Phase 7) `offset()`,
 `surface()` (`.dat` text + PNG/JPEG/BMP/GIF via `stb_image`), hand-rolled DXF (`LWPOLYLINE`/2D
-`POLYLINE`) and SVG (`path`/`polygon`/`polyline`/`rect`/`circle`/`ellipse`, nested
+`POLYLINE`) and SVG (a port of upstream's libsvg: shapes, strokes, `<use>`, layers, nested
 `transform=`, all path commands including elliptical arcs) 2D contour import in both module
 (Region geometry) and expression (Region value) contexts, and the `FontProvider` abstraction
 (`font_provider.hpp`) + built-in FreeType/HarfBuzz backend + `text()`/`textmetrics()`/
@@ -211,8 +211,23 @@ Challenges and Experiences"), `roof.cpp` was rewritten from scratch as a close p
 `roof_vd.cc`'s `voronoi_diagram_roof`/`vd_inner_faces`/`discretize_arc` (CGAL/Eigen/Clipper2Lib
 swapped for `manifold::vec2` arithmetic and `manifold::Triangulate`), on top of Boost.Polygon's
 Voronoi builder (fetched as just `boostorg/polygon` + `boostorg/config`, confirmed to need nothing
-else from Boost). Both `method` values dispatch to this same construction (no CGAL-based `"straight"`
-path exists in this port). **Verified independently**, not just "it compiles": a brute-force
+else from Boost). **`method="straight"` is its own construction** (`StraightSkeletonRoof` in
+`roof.cpp`), a true straight-skeleton roof written from the literature (Aichholzer et al. 1995;
+Felkel & Obdržálek 1998's event-driven wavefront) and the reference binary's black-box output --
+no CGAL, and no OpenSCAD roof source read. It simulates the shrinking wavefront event by event
+(edge, split and vertex events; a vertex event reconnects every wavefront edge at the meeting point
+by angle), O(n^2 log n): 5000 vertices in ~0.5 s. Its input is welded first (`weldContours`: corners
+within 2^-19 of the extent snapped together or onto edges, then a Clipper2 union), because a 2D
+union often hands back pieces sharing an edge as separate outlines a hairline apart, and spikes
+are cut away (`dropSpikes`). It matches OpenSCAD 2026.02.01 (`--enable=roof`) in volume, height and
+vertex set on every shape compared that the reference does not crash on -- the reference segfaults
+on many unions of rectangles/triangles that touch along edges, so those were checked only for being
+valid 45-degree roofs (roof area = floor area x sqrt 2). Until this landed both methods built the
+Voronoi roof, wrong for any concave outline. **Warnings**: `$fs`/`$fa` clamping (via the shared
+`Discretizer::fromCtx`) and `Unknown roof method '...'` (a non-string shown as str() shows it) are
+printed BEFORE the children run, as the reference does -- `computeRoofParams` therefore runs at
+`Op::PushBuiltinWrap` time like every other wrap kind (it used to be deferred to Pop on the belief
+that the warning followed the children). **Verified independently**, not just "it compiles": a brute-force
 distance-transform grid search over a square-frame-with-a-hole test case found the same ridge height
 (≈1.756) this implementation produces — the Python reference's own SDF fallback gets this case
 measurably wrong (≈1.5, ~15% low) since it was never more than a documented approximation for
@@ -1115,9 +1130,10 @@ grep for `ponytail:`.
   `toCrossSection`; no children/generate-time-bounds dependency, so its resolve/generate split is
   the simple kind (segment count for `r=` IS resolvable early here, unlike `rotate_extrude`'s,
   since `offset`'s own radius argument is already known at resolve time).
-- `src/builtins/roof.cpp` — `roof()`, built on Boost.Polygon's segment Voronoi diagram (see the
-  `roof()` note above for the full story of why this replaced an earlier straight-skeleton
-  approximation mid-Phase-6). `voronoiRoof` scales the merged cross-section's polygons into signed
+- `src/builtins/roof.cpp` — `roof()`: the default `method="voronoi"` built on Boost.Polygon's
+  segment Voronoi diagram (see the `roof()` note above for the full story of why this replaced an
+  earlier straight-skeleton approximation mid-Phase-6), and `method="straight"`'s straight-skeleton
+  wavefront simulation (`StraightSkeletonRoof`, same note). `voronoiRoof` scales the merged cross-section's polygons into signed
   32-bit integer coordinates (`chooseScale`, headroom below 2^31 for Boost.Polygon's own internal
   robustness margin), constructs the Voronoi diagram over the resulting segments, walks it
   (`vdInnerFaces`, discretizing parabolic point-vs-segment bisector edges via `discretizeArc`) to get
@@ -1248,9 +1264,13 @@ grep for `ponytail:`.
   the module *and* expression forms, enclosing transforms still apply to a selected element (it
   has to land where it does in the drawing), and **a filter that matches nothing imports nothing
   and warns** rather than falling back to the whole file — a cut layer that quietly became every
-  layer is the worst answer available. `layer=` stays DXF-only on purpose: upstream reuses the
-  name for SVG but reads only Inkscape's `inkscape:label`, a vendor convention rather than
-  anything SVG defines, so it cannot match a layer from any other tool. `id` had been in
+  layer is the worst answer available. `layer=` (and deprecated `layername=`) also selects in
+  SVG, as upstream does: an Inkscape layer (`inkscape:groupmode="layer"` with an
+  `inkscape:label`). Alone it takes that layer's own group; with `id=`/`class=` it restricts them
+  to elements inside the named layer at any depth. The selection rules were read off the binary:
+  the nearest selected or `display:none` ancestor-or-self decides whether a shape is drawn, so an
+  id selects an element even under a hidden layer, while `layer=` alone does not reach into a
+  hidden sublayer. The miss warning names `id`, `layer`, `class` in that order. `id` had been in
   `registry.cpp`'s declared parameter list since long before anything read it, so a script
   filtering by id was accepted in full and silently handed the whole drawing.
   `resolveFilePath()` (also declared here, defined in import.cpp) — resolves a file argument
@@ -1281,20 +1301,37 @@ grep for `ponytail:`.
   triangle-count parity.
 - `include/openscad_cpp_evaluator/dxf_svg_import.hpp`, `src/import/dxf_import.cpp`,
   `src/import/svg_import.cpp` — hand-rolled, dependency-free 2D-contour loaders (no XML/DXF library
-  pulled in, matching the plan's §9 dependency table). `loadDxfContours()` reads DXF's group-code
-  text format directly (closed `LWPOLYLINE`/2D `POLYLINE` entities only, optional layer filter) --
-  covers the same narrow entity set the reference's own `ezdxf`-based loader does, nothing more.
+  pulled in, matching the plan's §9 dependency table). `loadDxf()` reads DXF's group-code
+  text format directly and matches OpenSCAD 2026.02.01's import, established black-box (its DXF
+  source is GPL; do not read or port it): `LINE`/`CIRCLE`/`ARC`/`ELLIPSE`/`LWPOLYLINE`/`INSERT`
+  become segments (arcs by the circle fragment rules), points snap to a 1/1024 grid, segments chain
+  into paths that are ALL closed (an open chain gets a straight closing edge), filled even-odd;
+  `origin=`/`scale=`/`layer=` and its warnings ("Illegal value", "Not enough input values",
+  "Unsupported DXF Entity") as OpenSCAD has them. The notes atop `dxf_import.cpp` list the rules,
+  the two ellipse bugs deliberately not copied, and the `POLYLINE` extension.
   `loadSvgContours()` pairs a minimal recursive-descent XML tree parser (open/close/self-closing
-  tags, quoted attributes, comments/CDATA/prolog skipping, entity decoding — no namespace URI
-  resolution, a tag's `prefix:` is stripped textually) with a close port of the reference's own
-  path-command tokenizer/flattener (`M`/`L`/`H`/`V`/`C`/`S`/`Q`/`T`/`A`, both absolute and relative,
-  cubic/quadratic Bezier flattening, full elliptical-arc endpoint-to-center parameterization) plus
-  `rect`/`circle`/`ellipse`/`polygon`/`polyline` and nested `transform="matrix()/translate()/
-  scale()/rotate()"` composition (including through `<g>` groups), in SVG user units at the
-  point-transform step, `applyMat()` (named to avoid colliding with `std::apply` in an ADL lookup
-  that broke the build once — see its own comment). **Placement is `pageMap()`, a port of the
-  reference's `import_svg.cc`**: the page's `width`/`height` to mm (a unitless length at `dpi=`,
-  72 by default; `px` at 96), the `viewBox` scaled onto the page under `preserveAspectRatio`
+  tags, quoted attributes, comments/CDATA/prolog skipping, entity and character-reference
+  decoding, attribute whitespace normalisation; a tag keeps its `prefix:`, as libxml2 reports it,
+  so `<svg:rect>` is not a rect -- in OpenSCAD either) with **a port of upstream's MIT-licensed
+  `src/libsvg`** (its copyright notice is in the file): its `d` tokenizer with every quirk (a `-`
+  is a token, `1.5.5` is two numbers, a number with trailing junk is 0), Beziers in `max($fn, 20)`
+  segments, arcs and circles/ellipses through `Discretizer::circular` (circles at least 40),
+  rounded `rect`s rebuilt as path data printed at 6 digits, `transform` with `skewX`/`skewY` and
+  libsvg's argument-count checks, `<use>` of a shape in an earlier `<defs>` only, unknown
+  elements (`<a>`, `<symbol>`, `<switch>`) see-through with their transform ignored, and
+  **strokes**: an open subpath, `<line>` and `<polyline>` become their stroke's outline via
+  Clipper2's `ClipperOffset` at 2^27 per user unit (measured), with `stroke-width` (below 0.01 is
+  1), `stroke-linecap` and `stroke-linejoin` (`bevel` maps to Clipper's Square, as libsvg has it).
+  Each element then fills even-odd on its own and the elements union (`fill()`), which is what
+  the reference does: separate overlapping rects union, one path's overlapping subpaths cancel.
+  Two departures: an arc with a zero radius or coincident endpoints is a line or nothing, as the
+  SVG spec says, where libsvg divides by zero and draws NaN vertices at the origin; and
+  OpenSCAD's 2D pipeline drops vertices within ~1.1e-8 mm of collinear, which ours (any 2D
+  shape, not just SVG) does not -- spec `paths-cubic02` keeps two such vertices at an S-curve's
+  inflection. **Placement is `pageMap()`, matching the reference's `import_svg.cc` by its
+  output**: the page's `width`/`height` to mm (a unitless length at `dpi=`,
+  72 by default; `px` at 96; a `dpi` below 0.001 warns and is 72), the `viewBox` scaled onto the
+  page under `preserveAspectRatio`
   (default `xMidYMid meet`), and Y flipped about the page HEIGHT -- or about the drawing's centre
   with `center=true`. Negating Y alone, as this did before, put a unitless 100-unit drawing in 2.8x
   too large and below the X axis. Bounds match OpenSCAD 2026.02.01 (`SvgPlacement` tests).
@@ -1670,7 +1707,7 @@ the side-quad diagonal choice changes a twisted solid without changing its trian
   default below 3, so these are an extrude warped round Z. The warp inverts the solid for a positive
   angle, hence the mirror-in-Y dance.
 - Kept departure: `$fa`/`$fs` <= 0 fall back to 12/2 rather than upstream's clamp-to-0.01 with a warning.
-- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF/SVG import arcs don't read the discretizer.
+- Not ported: `linear_extrude(v=)` (accepted, ignored); DXF import arcs don't read the discretizer.
 
 ## Cancel and the module recursion limit (#554)
 

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.42.0
+Version: 1.44.0
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
-License-Expression: MIT
+License-Expression: MIT AND OFL-1.1
 License-File: LICENSE
+License-File: resources/fonts/LICENSE
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent

openscad_cpp_evaluator-1.44.0/external/openscad_cpp_parser/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 BelfrySCAD Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -287,14 +287,13 @@ enum class Op {
     // this AFTER would silently drop uncacheable/ManifoldCache taint
     // tracking for a rands() call embedded in the wrapper's own
     // arguments), computes this site's own params for every kind except
-    // Modifier (empty, no ctx push) and Roof (deferred to Pop -- see
-    // BuiltinWrapSite's own doc comment) via that kind's own native
+    // Modifier (empty, no ctx push) via that kind's own native
     // compute function (computeTransformParams/computeColorParams/etc.,
     // builtins.hpp) -- always a possibly-$-scoped child EvalContext,
     // pushed onto f.ctxChain unconditionally for every non-Modifier kind
-    // (Roof pushes it too, params or not) -- pushes a fresh ev.treeStack_
-    // frame, and stashes {params, randsBefore, siteIdx, (Roof only)
-    // deferredArgs} onto VmFrame::builtinWrapStack (a real per-frame LIFO
+    // -- pushes a fresh ev.treeStack_
+    // frame, and stashes {params, randsBefore, siteIdx} onto
+    // VmFrame::builtinWrapStack (a real per-frame LIFO
     // stack, not a single slot: Push/PopBuiltinWrap pairs can nest or
     // sequence within one frame's own instruction stream, e.g.
     // `translate(a) translate(b) recur();`). The compiler always emits a
@@ -311,12 +310,7 @@ enum class Op {
     // VmFrame::builtinWrapStack's own top entry FIRST (before anything
     // that can itself throw, e.g. Evaluator::setTreeDepthOrThrow below --
     // so the exception-teardown path's own pending count is already
-    // correct if THIS throws); for Roof only, computes `pending.params`
-    // HERE via computeRoofParams(ev, pending.deferredArgs, ctx) -- the one
-    // kind whose params computation has an observable side effect
-    // (ev.warn()) that must stay ordered AFTER children, unlike every
-    // other kind's params (computed at Push, before children, since
-    // nothing else in this group has an order-sensitive side effect); pops
+    // correct if THIS throws); pops
     // the ctx Push made (every kind except Modifier); pops ev.treeStack_
     // to retrieve the children this bracket's own body produced, and
     // builds the tagged CSGNode exactly like Evaluator::buildTreeNode's
@@ -956,10 +950,9 @@ struct CompiledChunk {
     // rotate_extrude()/projection()/offset()/roof()) share Transform/
     // Color's exact push-time-computed-params shape, just via a different
     // native compute function each (Op::PushBuiltinWrap's own runtime
-    // handler switches on `kind` to pick it) -- see that op's own doc
-    // comment for the one exception (Roof, whose params computation has
-    // to run at POP time instead, after children, to preserve an
-    // observable warn() ordering).
+    // handler switches on `kind` to pick it). Roof's warnings ($fs/$fa
+    // clamping, unknown method) therefore come before its children's
+    // output, as in OpenSCAD 2026.02.01.
     struct BuiltinWrapSite {
         enum class Kind {
             Transform,
@@ -977,7 +970,7 @@ struct CompiledChunk {
             RotateExtrude,
             Projection,
             Offset,
-            Roof,          // computed at POP time, not PUSH -- see this struct's own doc comment
+            Roof,
         };
         Kind kind;
         std::string tagName; // "translate"/"rotate"/.../"color"/"highlight"/"background"/"show_only"/"hull"/...

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -30,15 +30,6 @@ struct PendingBuiltinWrap {
     CSGParams params;
     std::uint64_t randsBefore = 0;
     int siteIdx = -1;
-    // Only populated for BuiltinWrapSite::Kind::Roof -- the already-
-    // resolved call arguments, retained across the whole bracket so
-    // Op::PopBuiltinWrap's handler can compute roof()'s own params AFTER
-    // children finish (computeRoofParams needs them; re-running
-    // resolveCallArgs at Pop time instead would re-evaluate every argument
-    // expression a second time -- double rands()/side effects). Every
-    // other kind computes its params at Push time and leaves this default-
-    // empty.
-    CallArgs deferredArgs;
 
     // ev.measuring_ as it stood immediately BEFORE this bracket opened.
     // Recorded for EVERY kind, not just Measure, so the exception teardown

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -188,7 +188,7 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
                                             double flatHeight = kTopLevel2dHeight);
 
 // A 3D affine transform as it acts on the XY plane: rows x and y, columns
-// x, y and translation -- what OpenSCAD's GeometryEvaluator applies to 2D
+// x, y and translation -- what OpenSCAD applies to 2D
 // geometry (z, and everything out of the plane, simply drops away).
 manifold::mat2x3 projectTo2d(const manifold::mat3x4& m);
 
@@ -203,10 +203,10 @@ bool projectSectionXform(ColoredBody& b);
 
 // Applies `m`, projected onto the plane, to a CrossSection. A singular
 // projection -- scale([0,1]), a quarter turn about X -- empties it, as
-// upstream's Polygon2d::transform does, and returns false.
+// OpenSCAD does, and returns false.
 bool transformSection(manifold::CrossSection& cs, const manifold::mat3x4& m);
 
-// Upstream's warning for that case, word for word.
+// OpenSCAD's warning for that case, word for word.
 inline constexpr const char* kZeroScale2dWarning = "Scaling a 2D object with 0 - removing object";
 
 } // namespace oscadeval

openscad_cpp_evaluator-1.44.0/include/openscad_cpp_evaluator/dxf_svg_import.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "openscad_cpp_evaluator/segments.hpp"
+
+#include <array>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+using Contour2d = std::vector<std::array<double, 2>>;
+
+// import()'s DXF arguments. `disc` carries $fn/$fa/$fs/$fe for arcs.
+struct DxfOptions {
+    std::optional<std::string> layer;
+    double xorigin = 0.0, yorigin = 0.0, scale = 1.0;
+    Discretizer disc;
+};
+
+// The outlines, to be filled even-odd, and OpenSCAD's warnings about the
+// file, in the order it prints them.
+struct DxfImport {
+    std::vector<Contour2d> contours;
+    std::vector<std::string> warnings;
+};
+
+// Hand-rolled DXF reader matching OpenSCAD 2026.02.01's import (see the
+// notes atop dxf_import.cpp): LINE, CIRCLE, ARC, ELLIPSE, LWPOLYLINE,
+// POLYLINE and INSERT, chained into closed outlines. Throws
+// std::runtime_error on I/O failure.
+DxfImport loadDxf(const std::string& path, const DxfOptions& opts = {});
+
+// SVG reader, as OpenSCAD 2026.02.01 reads it (a port of its MIT-licensed
+// libsvg): <path>, <rect>, <circle>, <ellipse>, <line>, <polygon>,
+// <polyline> and <use>, with transforms, display:none, and strokes -- an
+// open path, <line> or <polyline> is drawn as its stroke's outline. Curves
+// split by `disc`. Y is flipped (SVG's is down, OpenSCAD's is up). Throws
+// std::runtime_error on I/O/parse failure.
+//: Which part of the drawing to import. All unset means the whole file.
+//: `id` matches an element's `id` attribute; `cls` (not an OpenSCAD
+//: parameter) one entry of its space-separated `class` list; either takes
+//: everything under the element, so naming a <g> means "that group".
+//: `layer` names an Inkscape layer (inkscape:groupmode="layer", by its
+//: inkscape:label): alone it takes that layer, with id/cls it restricts
+//: them to elements inside it.
+struct SvgFilter {
+    std::optional<std::string> id;
+    std::optional<std::string> cls;
+    std::optional<std::string> layer;
+};
+
+// `matched`, when given, reports whether the filter found anything. A miss
+// imports nothing rather than falling back to the whole drawing; the caller
+// warns. Always true when no filter was set.
+// Placed as OpenSCAD places them: page units to mm (a unitless length at
+// `dpi`), the viewBox under preserveAspectRatio, Y flipped about the page
+// height -- or about the drawing's centre with `center`. The result is
+// filled: overlapping contours have already been combined.
+std::vector<Contour2d> loadSvgContours(const std::string& path,
+                                       const SvgFilter& filter = {},
+                                       bool* matched = nullptr,
+                                       double dpi = 72.0,
+                                       bool center = false,
+                                       const Discretizer& disc = {});
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -587,6 +587,11 @@ public:
     // warnCapture first when one is active. Every warning path goes through
     // here, including a ManifoldCache hit replaying a cached line.
     void emitWarning(const std::string& formatted);
+    // "ERROR: {message}{locSuffix(position)}" that does NOT stop the run:
+    // OpenSCAD logs several of its errors this way and carries on.
+    void nonFatalError(const std::string& message, const oscad::Position* position) {
+        emitWarning("ERROR: " + message + locSuffix(position));
+    }
 
     // Applies OpenSCAD's mixed-2D/3D rules to a node's children just
     // before its GenerateFn runs -- see csg_generate.cpp.

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/export.hpp

@@ -167,7 +167,7 @@ struct ExportSvgOptions {
 void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
               const ExportSvgOptions& opts = {});
 
-// DXF, the third 2D writer: OpenSCAD's own export_dxf.cc layout (an AC1006
+// DXF, the third 2D writer: byte-compatible with OpenSCAD's layout (an AC1006
 // header with the model's extents, one CONTINUOUS linetype, layer 0) and
 // every contour of every body a closed LWPOLYLINE on layer 0 -- holes are
 // contours like any other, as in OpenSCAD. A 1-vertex contour is a POINT
@@ -259,13 +259,10 @@ struct ExportPovOptions {
 // POV-Ray scene description. Every object splitBodiesForExport produces is
 // one mesh2 -- a welded vertex list, a texture per colour, and a texture
 // index per triangle, so per-triangle colour needs no unwelding -- with
-// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). That
-// is the difference from OpenSCAD's export_pov.cc, which writes every face
-// as its own flat polygon object. The rest of the scene is OpenSCAD's: its
-// header, MATERIAL finish and ior 1.32 interior, 27 lights around the
-// bounding box, its camera, and radiosity from rad_def.inc. Colour is rgbf
-// with filter = 1 - alpha, as OpenSCAD writes it. Numbers are the shortest
-// text that round-trips, in the classic locale.
+// inside_vector, which makes it a SOLID to POV-Ray (refraction, CSG). The
+// rest of the scene (material, lights, default camera) is spec section F2.
+// Colour is rgbf with filter = 1 - alpha. Numbers are the shortest text that
+// round-trips, in the classic locale.
 void writePov(const std::string& path, const std::vector<ExportObject>& objects,
               const ExportPovOptions& opts = {});
 

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/format_closure.hpp

@@ -3,6 +3,7 @@
 #include <string>
 
 namespace oscad {
+class ASTNode;
 class FunctionLiteral;
 }
 
@@ -16,5 +17,8 @@ namespace oscadeval {
 // precedence-minimal and which 94 places inside the parser depend on. See
 // format_closure.cpp for where each rule came from.
 std::string formatFunctionLiteral(const oscad::FunctionLiteral& fn);
+// Any expression, spelled the same way: what assert() quotes as its
+// condition ("Assertion '(a > 1)' failed").
+std::string formatExpression(const oscad::ASTNode& expr);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/import_builtin.hpp

@@ -9,12 +9,14 @@ class ASTNode;
 namespace oscadeval {
 
 class Evaluator;
+struct EvalContext;
 
 // import() used as an expression (not a geometry statement): returns a VNF
 // ([[verts],[faces]]) for a mesh file (.stl/.obj/.off/.3mf), or the JSON
 // file's content converted to native values (.json). DXF/SVG-as-Region
 // import lands alongside their module-context counterparts in a later
 // phase. Mirrors Evaluator._import_as_value (minus the dxf/svg branch).
-Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node);
+// `ctx` supplies $fn/$fa/$fs/$fe for an SVG's curves.
+Value importAsValue(Evaluator& ev, const CallArgs& args, const oscad::ASTNode& node, const EvalContext& ctx);
 
 } // namespace oscadeval

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/segments.hpp

@@ -11,34 +11,25 @@
 
 namespace oscadeval {
 
-// How curves become polygons: OpenSCAD's CurveDiscretizer (src/core/
-// CurveDiscretizer.cc, upstream master cc19000e0), ported. Every count here
-// matches the 2026.02.01 binary's.
-//
-// $fn > $fe > $fa/$fs. $fe is the most a curve's polygon may stray from the
-// true circle, measured along a radius to an edge's midpoint; when set (>=
-// 2^-20) it replaces $fa/$fs entirely. Upstream reads $fe only behind
-// --enable=discretization-by-error; this evaluator always honours it, and
-// advertises that as supported_feature("discretization-by-error").
-//
-// Departures from upstream, kept from before this port: $fa/$fs <= 0 fall
-// back to their defaults (12/2) rather than clamping to 0.01 with a warning.
+// How curves become polygons: segment and slice counts from $fn/$fe/$fa/$fs
+// (spec sections B7 and C6). $fe is always honoured here (OpenSCAD reads it
+// only behind --enable=discretization-by-error), advertised as
+// supported_feature("discretization-by-error").
 struct Discretizer {
     double fn = 0.0;
     double fe = 0.0;
     double fa = 12.0;
     double fs = 2.0;
 
-    // `warn`, when given, receives upstream's clamping warnings.
+    // `warn`, when given, receives the clamping warnings (spec section B7).
     static Discretizer fromCtx(const EvalContext& ctx, const std::function<void(const std::string&)>& warn = {});
     // Stored in, and read back from, a node's params -- they are part of its
     // cache key, and generate has only the params to go on.
     static Discretizer fromParams(const CSGParams& params);
     void store(CSGParams& params) const;
 
-    // Segments for `angle` degrees of arc at radius r. nullopt where
-    // upstream has none (r below 2^-20, a non-finite $fn/$fe/angle): every
-    // caller supplies its own fallback, as upstream's value_or() does.
+    // Segments for `angle` degrees of arc at radius r. nullopt where there is
+    // no count (spec section B7); every caller supplies its own fallback.
     std::optional<int> circular(double r, double angleDegrees = 360.0) const;
 
     // linear_extrude slice counts: twist without scale, twist with uniform
@@ -54,8 +45,8 @@ struct Discretizer {
                                          double scaleX, double scaleY, unsigned slices, unsigned segments) const;
 };
 
-// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r;
-// upstream's primitives fall back to 3.
+// Full-circle segment count from ctx's $fn/$fe/$fa/$fs at radius r, or 3
+// when there is none.
 int fnSegmentsFromCtx(const EvalContext& ctx, double r = 0.0,
                       const std::function<void(const std::string&)>& warn = {});
 

openscad_cpp_evaluator-1.44.0/include/openscad_cpp_evaluator/surface_load.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace oscadeval {
+
+// Height data for surface() (spec section D3). Never throws: a file that
+// cannot be read gives no heights and a warning, and the script carries on.
+// `heights[row * cols + col]`; `minVal` is what the base sits 1 below.
+struct SurfaceData {
+    std::vector<double> heights;
+    int rows = 0;
+    int cols = 0;
+    double minVal = 0;
+    std::vector<std::string> warnings;
+};
+SurfaceData loadSurface(const std::string& path, bool invert);
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/include/openscad_cpp_evaluator/value.hpp

@@ -268,12 +268,9 @@ Value vecSub(const Value& a, const Value& b);
 // behavior in the reference implementation -- revisit only if a real
 // script's `*` on a bool-containing vector is shown to need it.
 //
-// `error`, when non-null, receives the reference's own diagnostic text for
-// whichever undefined case was hit (multiply_visitor / multvecvec /
-// multmatvec / multvecmat in the reference's Value.cc) -- "vector*vector
-// requires matching lengths (2 != 3)", "Matrix must be rectangular. Problem
-// at row 1", and so on. applyBinaryOp warns with it; a caller that only
-// wants the value can leave it null. It is only written on an undef result.
+// `error`, when non-null, receives the diagnostic for whichever undefined
+// case was hit (spec section A6); applyBinaryOp warns with it. It is only
+// written on an undef result.
 Value matmul(const Value& a, const Value& b, std::string* error = nullptr);
 
 // OpenSCAD's echo()/str() number formatting: at most 6 significant digits,

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.42.0"
+version = "1.44.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"
-license = "MIT"
-license-files = ["LICENSE"]
+license = "MIT AND OFL-1.1"
+license-files = ["LICENSE", "resources/fonts/LICENSE"]
 authors = [{ name = "NeuSCAD Contributors" }]
 classifiers = [
     "Development Status :: 3 - Alpha",

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/src/CMakeLists.txt

@@ -68,7 +68,7 @@ target_include_directories(openscad_cpp_evaluator PRIVATE ${stb_SOURCE_DIR} ${CM
 add_dependencies(openscad_cpp_evaluator generate_bundled_font)
 
 target_link_libraries(openscad_cpp_evaluator PUBLIC openscad_cpp_parser manifold Boost::polygon)
-target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz)
+target_link_libraries(openscad_cpp_evaluator PRIVATE linenoise freetype harfbuzz Clipper2)
 target_compile_options(openscad_cpp_evaluator PRIVATE
   $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-Wall;-Wextra>
 )

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/src/builtins/booleans.cpp

@@ -392,8 +392,8 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
         }
 
         RoleSplit split = splitByRole(stmtBodies);
-        // A `%` statement is scenery, not an operand: upstream leaves it out
-        // of the CSG entirely (collectChildren skips isBackground()), so the
+        // A `%` statement is scenery, not an operand: OpenSCAD leaves it out
+        // of the CSG entirely, so the
         // NEXT statement is the minuend of a difference(), and an
         // intersection() is not cancelled by it. It was taken as an empty
         // operand, which emptied both. Only the `%` statement itself: a

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/src/builtins/builtins.hpp

@@ -246,17 +246,11 @@ CSGParams resolveOffset(Evaluator& ev, const oscad::ModularCall& node, EvalConte
 std::vector<ColoredBody> generateOffset(Evaluator& ev, const CSGParams& params,
                                          const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
 
-// roof() -- roof.cpp. Tier 1 (exact straight skeleton, stable single-
-// contour polygons) + Tier 3 (SDF/level-set fallback) only, per the plan --
-// Tier 2 (general multi-contour/hole straight skeleton) is a named,
-// documented follow-up, not silently dropped (see CLAUDE.md).
-// computeRoofParams: UNLIKE computeLinearExtrudeParams and friends above,
-// this is the params-computation half taken from AFTER evalChildren (it
-// calls ev.warn(), an observable side effect that must stay ordered after
-// any child's own echo/warn output) -- takes already-resolved CallArgs,
-// not a raw node+ctx, since Op::PushBuiltinWrap's own runtime handler
-// calls this at POP time. See its own doc comment (roof.cpp).
-CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx);
+// roof() -- roof.cpp. method="voronoi" (the default) is the Voronoi-diagram
+// roof, method="straight" the straight-skeleton one.
+// computeRoofParams: the params half, from already-resolved arguments;
+// it warns ($fs/$fa clamping, unknown method), before the children run.
+CSGParams computeRoofParams(Evaluator& ev, const CallArgs& args, EvalContext& effCtx, const oscad::Position* where);
 CSGParams resolveRoof(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 std::vector<ColoredBody> generateRoof(Evaluator& ev, const CSGParams& params,
                                        const std::vector<std::unique_ptr<CSGNode>>& children, const oscad::ASTNode& node);
@@ -271,15 +265,28 @@ std::vector<ColoredBody> generateSurface(Evaluator& ev, const CSGParams& params,
 // operand (and so empties an intersection) -- see resolveCsg.
 bool emptyStatementIsAnOperand(const oscad::ASTNode& stmt);
 
-// OpenSCAD's sin_degrees/cos_degrees: exact at multiples of 30 and 45 degrees.
+// OpenSCAD's sin_degrees/cos_degrees/tan_degrees/atan2_degrees: exact at
+// multiples of 30 and 45 degrees.
 double sinDeg(double x);
 double cosDeg(double x);
+double tanDeg(double x);
+double atan2Deg(double y, double x);
 
-// OpenSCAD's lookup_radius() (primitives_2d.cpp): `d` beats `r`, numbers only.
+// A radius/diameter argument pair: a numeric `d` beats `r`, numbers only.
 std::optional<double> lookupRadius(Evaluator& ev, const CallArgs& args, std::optional<int> rPos,
                                    std::optional<int> dPos, const std::string& rName, const std::string& dName,
                                    const oscad::Position* where);
 
+// "ERROR: <text>" at `where`, for input a primitive repairs and carries on with.
+void emitInputError(Evaluator& ev, const std::string& text, const oscad::Position* where);
+
+// Reads polygon() paths or polyhedron() faces (`listName`): each entry a
+// list of point indices. Entries that are not lists and indices that are not
+// numbers are reported as ERRORs and skipped; out-of-range indices are
+// WARNINGs and skipped. Every surviving entry is returned, however short.
+std::vector<std::vector<size_t>> readIndexLists(Evaluator& ev, const ValueList& lists, const std::string& listName,
+                                                size_t pointCount, const oscad::Position* where);
+
 CSGParams resolveText(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
 
 // The font size text()/textmetrics()/fontmetrics() draw at: `size`

{openscad_cpp_evaluator-1.42.0 → openscad_cpp_evaluator-1.44.0}/src/builtins/control.cpp

@@ -124,10 +124,8 @@ CSGParams resolveIntersectionFor(Evaluator& ev, const oscad::ModularIntersection
             // evalFor) -- mirrors _resolve_intersection_for's single
             // `_check_debug(body_node[0], loop_ctx, expr_level=True)`.
             if (!bodyNodes.empty()) ev.checkDebug(*bodyNodes.front(), parentCtx, /*forced=*/false, /*exprLevel=*/true);
-            // One operand per child STATEMENT of every iteration: upstream
-            // instantiates the children straight into the intersection
-            // node (control.cc), so they are intersected flat, not
-            // unioned per iteration first.
+            // One operand per child STATEMENT of every iteration: OpenSCAD
+            // intersects them flat, not unioned per iteration first.
             std::vector<const oscad::ASTNode*> assigns, stmts;
             for (const oscad::ASTNode* stmt : bodyNodes) {
                 if (stmt->kind() == oscad::NodeKind::Assignment) assigns.push_back(stmt);