openscad-cpp-evaluator 1.8.0__tar.gz → 1.10.0__tar.gz

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/CLAUDE.md

@@ -916,8 +916,8 @@ grep for `ponytail:`.
   — skip it and the mesh comes out non-manifold at the seam). Self-contained 2D geometry math here
   (`dot2`/`len2`/`norm2`, the parabola-canonical-frame rotation in `discretizeArc`) exists nowhere
   else in this codebase.
-- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all eight
-  formats `exportExtensions()` lists: 3MF, AMF, STL, OBJ, OFF, PLY, VRML, X3D (3MF via
+- `include/openscad_cpp_evaluator/export.hpp`, `src/export.cpp` — the writers for all nine
+  formats `exportExtensions()` lists: 3MF, AMF, STL, OBJ, OFF, PLY, SVG, VRML, X3D (3MF via
   `zip_stored.hpp`'s `writeDeflateZip`). **`exportExtensions()` is the one source of truth for
   which formats exist** — the Python facade and BelfrySCAD's dialog/CLI all ask it rather than
   restating the list, because three hand-written copies had already drifted far enough that `.off`
@@ -927,11 +927,22 @@ grep for `ponytail:`.
   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.
+  **`writeSvg` is the one 2D writer**, and the only one that reads `ColoredBody::section` rather
+  than `.body`: SVG 1.1, millimetres at 1:1, every contour of a body (holes included) a
+  `M .. L .. z` subpath of that body's single `<path>`. Model space is Y-up and SVG's is Y-down, so
+  the whole point transform is a Y negation; the page is the bounding box padded by **half the
+  stroke width** and rounded outward to whole millimetres, which is why the margin is not a
+  constant and why `stroke=false` shrinks the document. Both rules are OpenSCAD's, read from its
+  `export_svg.cc` — `ExportSvg.MatchesRealOpenscadByteForByte` pins the output against the real
+  binary's, vertex order and 6-vertex line wrap included. A 3D body in the list throws
+  ("Current top level object is not a 2D object"), as OpenSCAD refuses too: there is no projection
+  to fall back on. `ExportOptions::svg` carries OpenSCAD's five `-O export-svg/...` settings.
   `colored_body.hpp`/`.cpp`'s `toRenderableBodies()` (thin-extrudes any top-level 2D-only result to
-  a 1e-3-unit-tall `flatPreview` Manifold) must run on a body list before handing it to any of these
-  writers — none of them look at `ColoredBody::section` at all, only `.body`. `tools/cli/cli_lib.cpp`
-  is the only current caller; a future GUI/renderer caller needs the same call before passing
-  results to its own mesh consumer.
+  a 1-unit-tall `flatPreview` Manifold) must run on a body list before handing it to any of the
+  MESH writers — none of them look at `ColoredBody::section` at all, only `.body`. Not before
+  `writeSvg`, which needs the sections that step throws away, and which says so rather than writing
+  the slab's outline. `tools/cli/cli_lib.cpp` is the only current caller; a future GUI/renderer
+  caller needs the same call before passing results to its own mesh consumer.
 - `include/openscad_cpp_evaluator/function_builtins.hpp`, `src/builtins/function_builtins.cpp` —
   the math/string/list/type-check builtin *function* dispatch (`isBuiltinFunctionName`/
   `evalBuiltinFunction`), a completely separate namespace/table from `dispatch.hpp`'s builtin

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/bindings/module.cpp

@@ -357,7 +357,8 @@ struct Geometry {
 // exportModel, with the path/format/warnings marshalling. Releases the GIL:
 // a large export is seconds of Manifold work with no Python involved.
 nb::list exportModelPy(const std::string& path, const Geometry& geom, const std::string& format, bool asciiStl,
-                        bool stripSlivers, bool splitComponents) {
+                        bool stripSlivers, bool splitComponents, bool svgFill, const std::string& svgFillColor,
+                        bool svgStroke, const std::string& svgStrokeColor, double svgStrokeWidth) {
     std::vector<std::string> warnings;
     {
         nb::gil_scoped_release rel;
@@ -366,6 +367,11 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
         opts.asciiStl = asciiStl;
         opts.stripSlivers = stripSlivers;
         opts.splitComponents = splitComponents;
+        opts.svg.fill = svgFill;
+        opts.svg.fillColor = svgFillColor;
+        opts.svg.stroke = svgStroke;
+        opts.svg.strokeColor = svgStrokeColor;
+        opts.svg.strokeWidth = svgStrokeWidth;
         warnings = oscadeval::exportModel(path, geom.bodies, opts);
     }
     nb::list out;
@@ -375,7 +381,7 @@ nb::list exportModelPy(const std::string& path, const Geometry& geom, const std:
 
 nb::object evaluate(const std::string& path, nb::dict viewportParams,
                      std::shared_ptr<oscadeval::ManifoldCache> manifoldCache, bool profile,
-                     bool generate) {
+                     bool generate, bool strictCommas) {
     std::unordered_map<std::string, oscadeval::Value> vp = toViewportParams(viewportParams);
 
     std::vector<oscadeval::ColoredBody> bodies;
@@ -389,6 +395,12 @@ nb::object evaluate(const std::string& path, nb::dict viewportParams,
         nb::gil_scoped_release rel;
         auto logFn = [&echoes](const std::string& m) { echoes.push_back(m); };
         try {
+            // Constructed on the parsing thread, which is the one whose
+            // thread-local mode StrictCommaScope sets -- a flag flipped from
+            // Python before the call would sit on the wrong thread the
+            // moment a host evaluates off the main one.
+            std::optional<oscad::StrictCommaScope> strict;
+            if (strictCommas) strict.emplace();
             oscad::ParsedProgram program = oscad::getProgramFromFile(path);
             oscadeval::ResolvedUseScopes used = oscadeval::resolveUseScopes(program.nodes, path, logFn);
             oscadeval::Evaluator ev(logFn, nullptr, manifoldCache, oscadeval::DebugHooks{}, profile);
@@ -787,25 +799,33 @@ 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("split_components") = false, 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,
           "Write `geometry` to `path`, format taken from the extension unless `format` says otherwise. "
           "Returns the warnings to surface (open shells, mesh problems, slivers removed) rather than "
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
           "file cannot be opened.\n\n"
           "`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.");
+          "per colour however many pieces it is in.\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.");
 
     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.");
 
     m.def("evaluate", &evaluate, nb::arg("path"), nb::arg("viewport_params"), nb::arg("manifold_cache") = nullptr,
-          nb::arg("profile") = false, nb::arg("generate") = true,
+          nb::arg("profile") = false, nb::arg("generate") = true, nb::arg("strict_commas") = false,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).\n"
           "generate=False stops after the resolve pass: the script runs and reports everything "
           "it normally would, but no Manifold geometry is built, and neither bodies nor csg_tree "
-          "are populated.");
+          "are populated.\n\n"
+          "strict_commas=True makes a trailing comma in a call argument list or a let/for "
+          "assignment list a syntax error, as OpenSCAD 2021.01 did. List literals and parameter "
+          "declarations keep theirs, which 2021.01 accepted too.");
     m.def("parse_decls", &parseDecls, nb::arg("path"),
           "Parse a .scad file; return top-level declaration (namespace, name, start, end, line, column, origin) tuples.");
     m.def("strip_slivers", &stripSliversPy, nb::arg("verts"), nb::arg("tris"),

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/api.hpp

@@ -60,6 +60,44 @@ std::unique_ptr<Scope> buildScopes(const std::vector<ASTNode*>& ast);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<std::unique_ptr<ASTNode>>& ast, ScopeTable& table);
 std::unique_ptr<Scope> buildScopesInto(const std::vector<ASTNode*>& ast, ScopeTable& table);
 
+// Makes a trailing comma in a CALL ARGUMENT LIST a syntax error for as long
+// as it is in scope, matching OpenSCAD 2021.01:
+//
+//     cube(1,);                  // error while this is in scope
+//     echo(let(x = 1, y = 2,) x) // error -- let() parses as a call
+//     a = [2, 4,];               // still fine: 2021.01 accepts it too
+//     module m(a, b,) {}         // still fine, same reason
+//
+// One production (`arguments`) feeds every call form -- module
+// instantiation, function calls, echo, assert, render and let -- so this is
+// one rule, not a family of them. Parameter lists and list literals are
+// deliberately untouched: 2021.01 accepts a trailing comma in both, and
+// rejecting them would fail files it loads happily.
+//
+// A scope object rather than a parameter on all nine parse entry points:
+// this is a parse-wide mode, the same shape ParseNumberingScope already
+// uses, and threading a bool through getASTFromString/getASTFromFile/
+// getASTFromLibraryFile/getProgramFromFile and their helpers would touch
+// every one of them to say the same thing. Nests and restores on scope
+// exit, exceptions included; thread-local, so one thread parsing strictly
+// cannot change what another thread sees.
+//
+// getProgramFromFile()'s cache keys on this too -- a strict parse must not
+// be handed a tree an earlier lenient parse of the same file left behind.
+class StrictCommaScope {
+public:
+    StrictCommaScope();
+    ~StrictCommaScope();
+    StrictCommaScope(const StrictCommaScope&) = delete;
+    StrictCommaScope& operator=(const StrictCommaScope&) = delete;
+
+private:
+    bool previous_;
+};
+
+// Whether a StrictCommaScope is currently in effect on this thread.
+bool strictCommasEnabled();
+
 // Parses `code`. Throws ParseError (with the full caret diagnostic) on a
 // syntax error.
 //

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/external/openscad_cpp_parser/src/api.cpp

@@ -89,6 +89,17 @@ std::string formatSyntaxError(const ParserDriver& driver, const std::string& cod
 
 } // namespace
 
+namespace {
+// See StrictCommaScope (api.hpp). Thread-local so a strict parse on one
+// thread cannot change what another thread is parsing.
+thread_local bool g_strictCommas = false;
+} // namespace
+
+StrictCommaScope::StrictCommaScope() : previous_(g_strictCommas) { g_strictCommas = true; }
+StrictCommaScope::~StrictCommaScope() { g_strictCommas = previous_; }
+
+bool strictCommasEnabled() { return g_strictCommas; }
+
 std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const std::string& origin, SourceMap* sourceMap) {
     // Stamps every node this parse builds with one treeId and a dense
     // slot, so a ScopeTable can address it without the node carrying a
@@ -96,6 +107,7 @@ std::vector<std::unique_ptr<ASTNode>> parseAst(const std::string& code, const st
     ParseNumberingScope numbering;
 
     ParserDriver driver(origin);
+    driver.strictCommas = g_strictCommas;
     lexerBeginString(code);
     yy::parser parser(driver);
     int rc = parser.parse();
@@ -258,7 +270,8 @@ namespace {
 using FileAst = std::vector<std::unique_ptr<ASTNode>>;
 using FileAstPtr = std::shared_ptr<const FileAst>;
 
-// One entry per (file, comments) -- keyed by PATH, with the content stamp
+// One entry per (file, comments, strict-commas) -- keyed by PATH, with the
+// content stamp
 // stored beside the tree rather than in the key. A stale stamp REPLACES the
 // entry instead of adding a second one: an editor re-renders on every save,
 // and a stamp-in-the-key cache would keep a full copy of every version the
@@ -266,11 +279,18 @@ using FileAstPtr = std::shared_ptr<const FileAst>;
 struct CacheKey {
     std::string path;
     bool comments;
-    bool operator==(const CacheKey& o) const { return comments == o.comments && path == o.path; }
+    // Part of the key, not incidental: the same file parses differently
+    // under StrictCommaScope, so a strict parse must not be served a tree an
+    // earlier lenient parse of it left here (and vice versa).
+    bool strictCommas;
+    bool operator==(const CacheKey& o) const {
+        return comments == o.comments && strictCommas == o.strictCommas && path == o.path;
+    }
 };
 struct CacheKeyHash {
     size_t operator()(const CacheKey& k) const {
-        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U);
+        return std::hash<std::string>{}(k.path) ^ (k.comments ? 0x5bf03635U : 0U)
+               ^ (k.strictCommas ? 0x9e3779b9U : 0U);
     }
 };
 struct CacheEntry {
@@ -290,7 +310,7 @@ FileAstPtr parseFileShared(const std::string& absPath, bool includeComments) {
     const auto written = fs::last_write_time(absPath, ec);
     const std::int64_t stampMtime = ec ? 0 : static_cast<std::int64_t>(written.time_since_epoch().count());
 
-    const CacheKey key{absPath, includeComments};
+    const CacheKey key{absPath, includeComments, g_strictCommas};
     {
         std::lock_guard<std::mutex> lock(g_astCacheMutex);
         auto it = g_astCache.find(key);

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -39,6 +39,9 @@ public:
     std::string origin_;
     NodeList result;
     bool hadError = false;
+    // Copied from the ambient StrictCommaScope at parse start (api.cpp), so
+    // one parse's mode cannot change under it mid-run.
+    bool strictCommas = false;
     int errorLine = 0;
     int errorColumn = 0;
     int errorOffset = 0;

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/external/openscad_cpp_parser/src/grammar/parser.y

@@ -247,7 +247,18 @@ parameter:
 arguments:
     %empty                    { $$ = NodeList{}; }
   | argument_seq               { $$ = std::move($1); }
-  | argument_seq ","            { $$ = std::move($1); }
+    // The trailing comma OpenSCAD 2021.01 rejected. Still parsed, then
+    // reported -- @2 is the comma itself, so the caret lands on it rather
+    // than on the whole argument list, which a %expect-style grammar split
+    // could not manage. This one production feeds every call form (module
+    // instantiation, function calls, echo, assert, render, and let), which
+    // is why the whole feature is one rule. See StrictCommaScope (api.hpp).
+  | argument_seq ","            {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in argument list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 argument_seq:
@@ -263,7 +274,18 @@ argument:
 assignments_expr:
     %empty                          { $$ = NodeList{}; }
   | assignment_expr_seq              { $$ = std::move($1); }
-  | assignment_expr_seq ","           { $$ = std::move($1); }
+    // 2021.01 rejected this one too. `let` does NOT go through `arguments`
+    // in this grammar -- it has its own assignment list, shared with `for`
+    // and `intersection_for` -- so the feature is two productions, not the
+    // one it looks like. 2021.01 rejects a trailing comma in all four:
+    // let(x=1,), for(i=[0:2],), intersection_for(i=[0:1],) and the list
+    // comprehension forms of for. See StrictCommaScope (api.hpp).
+  | assignment_expr_seq ","           {
+        if (driver.strictCommas) {
+            driver.reportError(@2, "trailing comma in assignment list");
+        }
+        $$ = std::move($1);
+    }
   ;
 
 assignment_expr_seq:

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -26,6 +26,7 @@ add_executable(oscad_tests
   test_ast_generation.cpp
   test_node_str.cpp
   test_render_expression.cpp
+  test_strict_commas.cpp
 )
 target_link_libraries(oscad_tests PRIVATE openscad_cpp_parser GTest::gtest_main)
 

openscad_cpp_evaluator-1.10.0/external/openscad_cpp_parser/tests/test_strict_commas.cpp

@@ -0,0 +1,117 @@
+// StrictCommaScope: a trailing comma in a call argument list is an error,
+// matching OpenSCAD 2021.01 (BelfrySCAD issue #362).
+//
+// The scope is deliberately narrow. Measured against 2021.01 itself, it
+// rejected a trailing comma in CALL ARGUMENTS and accepted one everywhere
+// else -- list literals, list comprehensions, and module/function parameter
+// declarations all take one, in 2021.01 as in every version since. Rejecting
+// those would fail files 2021.01 loads happily, so they are left alone and
+// this file says so case by case.
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscad;
+
+namespace {
+
+// Two productions carry it: `arguments` (every call form) and
+// `assignments_expr` (let/for/intersection_for). `let` is NOT a call in this
+// grammar -- it has its own assignment list -- which the first draft of this
+// feature got wrong and this test caught.
+const char* const kRejected[] = {
+    "cube(1,);",                            // module instantiation
+    "translate([0,0,0],) cube(1);",         // ...with a child
+    "function g(x) = x; y = g(1,);",        // user function call
+    "y = max(1, 2,);",                      // builtin function call
+    "y = str(\"a\", \"b\",);",
+    "echo(1, 2,);",
+    "assert(true, \"m\",);",
+    // assignments_expr, not arguments
+    "y = let(x = 1, y = 2,) x + y;",
+    "let(x = 1,) cube(x);",
+    "for (i = [0:2],) cube(i);",
+    "intersection_for (i = [0:1],) cube(1);",
+    "a = [for (i = [0:1],) i];",
+};
+
+// Accepted by 2021.01, so accepted here even under the scope.
+const char* const kAccepted[] = {
+    "a = [2, 4,];",                         // list literal
+    "a = [for (i = [0:2]) i,];",            // list comprehension
+    "a = [each [1, 2],];",
+    "module m(a, b,) {} m(1, 2);",          // module parameter declaration
+    "function f(a, b,) = a + b;",           // function parameter declaration
+    "cube(1);",                             // no trailing comma at all
+    "y = max(1, 2);",
+};
+
+} // namespace
+
+TEST(StrictCommas, CallArgumentTrailingCommaIsAnErrorInScope) {
+    StrictCommaScope strict;
+    for (const char* src : kRejected) {
+        EXPECT_THROW(parseSrc(src), ParseError) << src;
+    }
+}
+
+TEST(StrictCommas, EverythingElseKeepsItsTrailingComma) {
+    StrictCommaScope strict;
+    for (const char* src : kAccepted) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, OffByDefault) {
+    // The whole set parses without the scope -- this is opt-in, and every
+    // existing caller must be unaffected.
+    for (const char* src : kRejected) {
+        EXPECT_NO_THROW(parseSrc(src)) << src;
+    }
+}
+
+TEST(StrictCommas, ScopeNestsAndRestores) {
+    EXPECT_FALSE(strictCommasEnabled());
+    {
+        StrictCommaScope outer;
+        EXPECT_TRUE(strictCommasEnabled());
+        {
+            StrictCommaScope inner;
+            EXPECT_TRUE(strictCommasEnabled());
+        }
+        EXPECT_TRUE(strictCommasEnabled()) << "an inner scope must not switch it off";
+    }
+    EXPECT_FALSE(strictCommasEnabled());
+}
+
+TEST(StrictCommas, RestoresWhenAParseThrows) {
+    try {
+        StrictCommaScope strict;
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError&) {
+    }
+    EXPECT_FALSE(strictCommasEnabled()) << "the scope must unwind with the exception";
+}
+
+TEST(StrictCommas, TheErrorPointsAtTheComma) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("cube(1,);");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in argument list"), std::string::npos) << what;
+    }
+}
+
+TEST(StrictCommas, AnAssignmentListSaysSo) {
+    StrictCommaScope strict;
+    try {
+        parseSrc("y = let(x = 1,) x;");
+        FAIL() << "expected ParseError";
+    } catch (const ParseError& e) {
+        const std::string what = e.what();
+        EXPECT_NE(what.find("trailing comma in assignment list"), std::string::npos) << what;
+    }
+}

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/include/openscad_cpp_evaluator/colored_body.hpp

@@ -16,6 +16,10 @@ enum class BodyRole { Normal, Highlight, Background, ShowOnly };
 // A single piece of evaluated geometry: exactly one of `body` (3D) or
 // `section` (2D) is set, never both -- mirrors the Python reference's
 // ColoredBody (body: Optional[Manifold] XOR section: Optional[CrossSection]).
+// ONE exception, and it is deliberate: toRenderableBodies() leaves the
+// `section` in place on the `flatPreview` body it extrudes, so a 2D writer
+// downstream still has the contours. `flatPreview` is the flag that says
+// so; nothing else sets both.
 // `role`/`triColors` are later-phase fields (modifier tagging -- Phase 3;
 // multi-color CSG merges -- Phase 3/8) included now so the struct shape
 // doesn't need reworking when those land.

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/include/openscad_cpp_evaluator/export.hpp

@@ -127,6 +127,36 @@ void writeOff(const std::string& path, const std::vector<ColoredBody>& bodies);
 // no geometry to export.
 void writeThreeMf(const std::string& path, const std::vector<ExportObject>& objects);
 
+// -- 2D ------------------------------------------------------------------
+
+// Options for the SVG writer, named and defaulted after OpenSCAD's own
+// `-O export-svg/...` set. `stroke`/`strokeWidth` are not purely cosmetic:
+// half the stroke width pads the page, so turning the stroke off shrinks
+// the document.
+struct ExportSvgOptions {
+    bool fill = false;
+    std::string fillColor = "white";
+    bool stroke = true;
+    std::string strokeColor = "black";
+    double strokeWidth = 0.35;
+};
+
+// SVG 1.1 of a 2D-only model, in millimetres at 1:1 -- so a print of it
+// measures what the script says. Every contour of a body, holes included,
+// becomes a `M .. L .. z` subpath of that body's single `<path>`.
+//
+// Model space is Y-up and SVG's is Y-down, so the whole point transform is
+// a Y negation. The page is the bounding box padded by half the stroke
+// width and rounded OUTWARD to whole millimetres, which is why the margin
+// is not a constant (0 to just under 1mm per side, depending where the
+// bounds fall). Both rules are OpenSCAD's, read from its export_svg.cc and
+// checked against its binary.
+//
+// Throws std::runtime_error if any top-level body is 3D -- OpenSCAD's rule,
+// and the only honest answer, since there is no projection to fall back on.
+void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies,
+              const ExportSvgOptions& opts = {});
+
 // -- one entry point ------------------------------------------------------
 
 struct ExportOptions {
@@ -144,6 +174,8 @@ struct ExportOptions {
     // pieces it is in; see that function's own comment for why the default
     // moved here.
     bool splitComponents = false;
+    // .svg only.
+    ExportSvgOptions svg;
 };
 
 // Writes `bodies` to `path`, choosing the writer from the extension (or

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/python/openscad_cpp_evaluator/__init__.py

@@ -292,7 +292,10 @@ 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) -> list:
+                 strip_slivers: bool = True, split_components: bool = False,
+                 svg_fill: bool = False, svg_fill_color: str = "white",
+                 svg_stroke: bool = True, svg_stroke_color: str = "black",
+                 svg_stroke_width: float = 0.35) -> list:
     """Write `geometry` to `path`. Returns the warnings to surface.
 
     `geometry` is the handle an Evaluator stashes on itself as
@@ -312,10 +315,17 @@ 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.
+
+    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
+    purely cosmetic. An `.svg` export of anything 3D raises, as OpenSCAD's
+    does -- there is no projection to fall back on.
     """
     try:
         return list(_ext.export_model(path, geometry, format, ascii_stl, strip_slivers,
-                                       split_components))
+                                       split_components, svg_fill, svg_fill_color,
+                                       svg_stroke, svg_stroke_color, svg_stroke_width))
     except Exception as e:
         raise EvalError(str(e)) from e
 
@@ -497,7 +507,7 @@ class Evaluator:
         self.dyn_explicit = set()
 
     def evaluate(self, source_path: str, viewport_params: Optional[dict] = None,
-                 generate: bool = True):
+                 generate: bool = True, strict_commas: bool = False):
         """Run `source_path` and return (bodies, id_to_node).
 
         `generate=False` stops after the resolve pass. The script still runs
@@ -508,6 +518,13 @@ class Evaluator:
         the geometry without skipping the language.
 
         Ignored on the debugger path, which has no geometry handle anyway.
+
+        `strict_commas=True` makes a trailing comma in a call argument list
+        or a let/for assignment list a syntax error, as OpenSCAD 2021.01 did
+        -- `cube(1,)` and `let(x = 1,)`, but NOT `[2, 4,]` or
+        `module m(a, b,)`, which 2021.01 accepted. For checking a script
+        against that version; off, and no divergence from current OpenSCAD,
+        otherwise. Also ignored on the debugger path.
         """
         vp = viewport_params or {}
         try:
@@ -528,7 +545,8 @@ class Evaluator:
             else:
                 (body_dicts, echoes, id_spans, csg_tree, profile_result, dyn,
                  dyn_explicit, geometry) = _ext.evaluate(
-                    source_path, vp, self._manifold_cache, self._profile, generate)
+                    source_path, vp, self._manifold_cache, self._profile, generate,
+                    strict_commas)
                 # The evaluated bodies, still on the C++ side. Stashed like
                 # csg_tree/profile_result rather than returned, so
                 # evaluate()'s own 2-tuple result is unchanged -- callers

{openscad_cpp_evaluator-1.8.0 → openscad_cpp_evaluator-1.10.0}/src/colored_body.cpp

@@ -43,6 +43,13 @@ std::vector<ColoredBody> toRenderableBodies(const std::vector<ColoredBody>& bodi
             flat.body = flat.body->Transform(cb.sectionXform);
             flat.color = cb.color;
             flat.flatPreview = true;
+            // Carried, not consumed: the 2D writers (writeSvg) need the
+            // contours, and every caller that exports goes through this
+            // conversion first -- the Python binding hands ONE body list to
+            // both the renderer and export. Dropping it here made an SVG
+            // export of any 2D script impossible from Python.
+            flat.section = cb.section;
+            flat.sectionXform = cb.sectionXform;
             flat.role = cb.role;
             out.push_back(std::move(flat));
         } else {