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

{openscad_cpp_evaluator-1.9.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.9.0 → openscad_cpp_evaluator-1.10.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.9.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;
@@ -793,14 +799,19 @@ 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 "

{openscad_cpp_evaluator-1.9.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.9.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.9.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.9.0"
+version = "1.10.0"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.9.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
 

{openscad_cpp_evaluator-1.9.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 {

{openscad_cpp_evaluator-1.9.0 → openscad_cpp_evaluator-1.10.0}/src/export.cpp

@@ -999,8 +999,117 @@ void writeOffMesh(const std::string& path, const manifold::MeshGL& mesh) {
 
 } // namespace
 
+namespace {
+
+// The contours of one 2D body, projected to XY.
+//
+// A section can carry a transform a CrossSection itself cannot hold -- a Z
+// offset, a rotation out of the plane (ColoredBody::sectionXform). Applying
+// it and keeping x/y is the top view, which is the only thing a flat page
+// can show; for the overwhelmingly common case (no such transform) it is
+// the identity and the points pass through untouched.
+manifold::Polygons sectionContours(const ColoredBody& cb) {
+    manifold::Polygons polys = cb.section->ToPolygons();
+    const manifold::mat3x4& m = cb.sectionXform;
+    for (manifold::SimplePolygon& contour : polys) {
+        for (manifold::vec2& p : contour) {
+            const double x = m[0].x * p.x + m[1].x * p.y + m[3].x;
+            const double y = m[0].y * p.x + m[1].y * p.y + m[3].y;
+            p = manifold::vec2(x, y);
+        }
+    }
+    return polys;
+}
+
+} // namespace
+
+void writeSvg(const std::string& path, const std::vector<ColoredBody>& bodies, const ExportSvgOptions& opts) {
+    // OpenSCAD's own wording, and its rule: 2D export needs an all-2D top
+    // level. There is no sane projection to fall back on -- a silhouette
+    // would be a different model from the one the script describes -- so
+    // refusing is the honest answer.
+    const char* kNot2d = "Current top level object is not a 2D object";
+
+    std::vector<manifold::Polygons> perBody;
+    double minx = 0, miny = 0, maxx = 0, maxy = 0;
+    bool any = false;
+    for (const ColoredBody& cb : bodies) {
+        if (!isExportable(cb)) continue;
+        // The section decides, not the Manifold: a body that has been
+        // through toRenderableBodies() carries BOTH -- a 1-unit slab
+        // extruded so a 2D script has something to show, and the contours
+        // it came from. Those contours are the real geometry, and the
+        // binding hands export that same converted list, so reading `body`
+        // first would make SVG unreachable for every 2D script.
+        if (!cb.section) {
+            if (cb.isDisplayOnly()) throw std::runtime_error(kNot2d);
+            if (cb.body && !cb.body->IsEmpty()) throw std::runtime_error(kNot2d);
+            continue;
+        }
+        manifold::Polygons polys = sectionContours(cb);
+        for (const manifold::SimplePolygon& contour : polys) {
+            for (const manifold::vec2& p : contour) {
+                if (!any) {
+                    minx = maxx = p.x;
+                    miny = maxy = p.y;
+                    any = true;
+                } else {
+                    minx = std::min(minx, p.x);
+                    maxx = std::max(maxx, p.x);
+                    miny = std::min(miny, p.y);
+                    maxy = std::max(maxy, p.y);
+                }
+            }
+        }
+        perBody.push_back(std::move(polys));
+    }
+    if (!any) throw std::runtime_error("No geometry to export");
+
+    // Page = bounding box, padded by half the stroke (the stroke straddles
+    // the contour, so half of it lies outside), rounded outward to whole
+    // millimetres. Note the Y terms use -maxy/-miny: the negation below
+    // turns the TOP of the model into the most negative coordinate.
+    const double pad = opts.stroke ? opts.strokeWidth / 2.0 : 0.0;
+    const long left = static_cast<long>(std::floor(minx - pad));
+    const long top = static_cast<long>(std::floor(-maxy - pad));
+    const long right = static_cast<long>(std::ceil(maxx + pad));
+    const long bottom = static_cast<long>(std::ceil(-miny + pad));
+    const long width = right - left;
+    const long height = bottom - top;
+
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+
+    const std::string stroke = opts.stroke ? opts.strokeColor : "none";
+    const std::string fill = opts.fill ? opts.fillColor : "none";
+
+    out << "<?xml version=\"1.0\" standalone=\"no\"?>\n"
+        << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" "
+            "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"
+        << "<svg width=\"" << width << "mm\" height=\"" << height << "mm\" viewBox=\"" << left << " " << top
+        << " " << width << " " << height << "\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n"
+        << "<title>OpenSCAD Model</title>\n";
+
+    for (const manifold::Polygons& polys : perBody) {
+        out << "<path d=\"\n";
+        for (const manifold::SimplePolygon& contour : polys) {
+            if (contour.empty()) continue;
+            out << "M " << contour[0].x << "," << -contour[0].y;
+            for (size_t i = 1; i < contour.size(); ++i) {
+                out << " L " << contour[i].x << "," << -contour[i].y;
+                if ((i % 6) == 5) out << "\n";
+            }
+            out << " z\n";
+        }
+        out << "\" stroke=\"" << stroke << "\" fill=\"" << fill << "\" stroke-width=\"" << opts.strokeWidth
+            << "\"/>\n";
+    }
+    out << "</svg>\n";
+}
+
 const std::vector<std::string>& exportExtensions() {
-    static const std::vector<std::string> exts = {".3mf", ".amf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"};
+    static const std::vector<std::string> exts = {".3mf", ".amf", ".stl", ".obj", ".off",
+                                                  ".ply", ".svg", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -1021,6 +1130,14 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         }
     };
 
+    if (ext == ".svg") {
+        // 2D, and nothing the mesh pipeline below does applies: no merge,
+        // no sliver strip, no manifoldness check. Contours are what they
+        // are.
+        writeSvg(path, bodies, opts.svg);
+        return warnings;
+    }
+
     if (isMultiObject(ext)) {
         // These keep the parts as separate objects, so each is checked on
         // its own -- that is what the file contains.

{openscad_cpp_evaluator-1.9.0 → openscad_cpp_evaluator-1.10.0}/tests/test_export.cpp

@@ -258,3 +258,185 @@ TEST(ExportAmf, AMultiColouredObjectBecomesOneVolumePerColour) {
     EXPECT_EQ(countOf(xml, "<material id="), 2u);
     std::remove(path.c_str());
 }
+
+// -- SVG (2D) --------------------------------------------------------------
+
+namespace {
+
+std::string readText(const std::string& path) {
+    std::ifstream in(path);
+    return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+}
+
+// Write `code` as SVG and return the file's text, deleting the file.
+std::string svgOf(const std::string& code, const std::string& name, const ExportSvgOptions& opts = {}) {
+    const std::string path = tempPath(name).string();
+    writeSvg(path, evalToBodies(code), opts);
+    const std::string text = readText(path);
+    std::remove(path.c_str());
+    return text;
+}
+
+std::string firstLineContaining(const std::string& text, const std::string& needle) {
+    const size_t at = text.find(needle);
+    if (at == std::string::npos) return "";
+    const size_t start = text.rfind('\n', at);
+    const size_t end = text.find('\n', at);
+    return text.substr(start == std::string::npos ? 0 : start + 1,
+                        (end == std::string::npos ? text.size() : end) - (start == std::string::npos ? 0 : start + 1));
+}
+
+} // namespace
+
+// The page rule is NOT a fixed 1mm margin -- it is the bounding box padded
+// by half the stroke width, then rounded outward to whole millimetres. The
+// three cases below are the ones that tell those two rules apart, and each
+// header is what real OpenSCAD 2026.02.01 wrote for the same model.
+TEST(ExportSvg, PageIsStrokePaddedBoundsRoundedOutward) {
+    const std::string text = svgOf("square([70.4, 25.3]);", "page_default.svg");
+    EXPECT_EQ(firstLineContaining(text, "<svg "),
+              "<svg width=\"72mm\" height=\"27mm\" viewBox=\"-1 -26 72 27\" "
+              "xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">");
+}
+
+TEST(ExportSvg, NoStrokeMeansNoStrokePadding) {
+    ExportSvgOptions opts;
+    opts.stroke = false;
+    const std::string text = svgOf("square([70.4, 25.3]);", "page_nostroke.svg", opts);
+    EXPECT_EQ(firstLineContaining(text, "<svg "),
+              "<svg width=\"71mm\" height=\"26mm\" viewBox=\"0 -26 71 26\" "
+              "xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">");
+    EXPECT_NE(text.find("stroke=\"none\""), std::string::npos);
+}
+
+TEST(ExportSvg, WiderStrokeGrowsThePage) {
+    ExportSvgOptions opts;
+    opts.strokeWidth = 4.0;
+    const std::string text = svgOf("square([70.4, 25.3]);", "page_wide.svg", opts);
+    EXPECT_EQ(firstLineContaining(text, "<svg "),
+              "<svg width=\"75mm\" height=\"30mm\" viewBox=\"-2 -28 75 30\" "
+              "xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">");
+}
+
+TEST(ExportSvg, NegatesY) {
+    // Model Y 10..15 must come out as SVG y -15..-10: SVG's Y grows
+    // downward. Getting this backwards mirrors the drawing, and on a
+    // symmetric model it is invisible -- hence an asymmetric one.
+    const std::string text = svgOf("translate([0,10]) square([5,5]);", "negate_y.svg");
+    EXPECT_NE(text.find(",-15"), std::string::npos);
+    EXPECT_NE(text.find(",-10"), std::string::npos);
+    EXPECT_EQ(text.find(",15"), std::string::npos);
+}
+
+TEST(ExportSvg, HoleIsAnotherSubpathOfTheSamePath) {
+    const std::string text =
+        svgOf("difference() { square([40,25]); translate([20,12]) circle(5, $fn=16); }", "hole.svg");
+    EXPECT_EQ(countOf(text, "<path "), 1u);  // one body, one <path>
+    EXPECT_EQ(countOf(text, "M "), 2u);      // outline + hole
+    EXPECT_EQ(countOf(text, " z"), 2u);
+    // fill="none" is why the hole needs no winding rule to show through.
+    EXPECT_NE(text.find("fill=\"none\""), std::string::npos);
+}
+
+TEST(ExportSvg, DisjointShapesShareOneBodyAndOnePath) {
+    const std::string text = svgOf("square(10); translate([20,0]) square(10);", "disjoint.svg");
+    EXPECT_EQ(countOf(text, "M "), 2u);
+    // 0..30 in x, padded by 0.175 and rounded out: -1 .. 31.
+    EXPECT_NE(text.find("<svg width=\"32mm\" height=\"12mm\" viewBox=\"-1 -11 32 12\""), std::string::npos);
+}
+
+TEST(ExportSvg, StrokeAndFillOptionsReachTheFile) {
+    ExportSvgOptions opts;
+    opts.fill = true;
+    opts.fillColor = "#ffcc00";
+    opts.strokeColor = "red";
+    opts.strokeWidth = 0.5;
+    const std::string text = svgOf("square(10);", "styled.svg", opts);
+    EXPECT_NE(text.find("stroke=\"red\""), std::string::npos);
+    EXPECT_NE(text.find("fill=\"#ffcc00\""), std::string::npos);
+    EXPECT_NE(text.find("stroke-width=\"0.5\""), std::string::npos);
+}
+
+TEST(ExportSvg, SectionTransformIsApplied) {
+    // A transform a CrossSection cannot hold -- here a rotation out of the
+    // XY plane -- lives in ColoredBody::sectionXform instead. Ignoring it
+    // drew the unrotated shape. Tilting a 10mm square 45 degrees about X
+    // foreshortens it to 10*cos(45) = 7.07107 on the page.
+    const std::string text = svgOf("rotate([45,0,0]) square([10,10]);", "xform.svg");
+    EXPECT_NE(text.find("-7.07107"), std::string::npos);
+    EXPECT_NE(text.find("<svg width=\"12mm\" height=\"9mm\" viewBox=\"-1 -8 12 9\""), std::string::npos);
+}
+
+TEST(ExportSvg, InPlaneTranslationLandsWhereTheModelIs) {
+    const std::string text = svgOf("translate([3,4]) square([5,5]);", "moved.svg");
+    EXPECT_NE(text.find("M 3,-4"), std::string::npos);
+    EXPECT_NE(text.find("L 8,-9"), std::string::npos);
+}
+
+TEST(ExportSvg, RefusesA3dModel) {
+    std::vector<ColoredBody> bodies = evalToBodies("cube(10);");
+    EXPECT_THROW(writeSvg(tempPath("solid.svg").string(), bodies), std::runtime_error);
+}
+
+TEST(ExportSvg, RefusesMixed2dAnd3d) {
+    std::vector<ColoredBody> bodies = evalToBodies("cube(10); translate([20,0]) square(5);");
+    EXPECT_THROW(writeSvg(tempPath("mixed.svg").string(), bodies), std::runtime_error);
+}
+
+TEST(ExportSvg, WorksOnRenderableBodiesToo) {
+    // The Python binding runs toRenderableBodies() once and hands the SAME
+    // list to the renderer and to export, so a 2D script reaches writeSvg
+    // as a 1-unit slab that still carries its section. The contours are
+    // what gets written -- the slab's own outline would be the same shape
+    // but is not the point; the section is the geometry.
+    std::vector<ColoredBody> renderable = toRenderableBodies(evalToBodies("square([70.4, 25.3]);"));
+    ASSERT_TRUE(renderable[0].flatPreview);
+    ASSERT_TRUE(renderable[0].section.has_value());
+    const std::string path = tempPath("preview.svg").string();
+    writeSvg(path, renderable);
+    const std::string text = readText(path);
+    std::remove(path.c_str());
+    EXPECT_NE(text.find("<svg width=\"72mm\" height=\"27mm\" viewBox=\"-1 -26 72 27\""), std::string::npos);
+    EXPECT_EQ(countOf(text, "M "), 1u);
+}
+
+TEST(ExportSvg, NoGeometryThrows) {
+    std::vector<ColoredBody> empty;
+    EXPECT_THROW(writeSvg(tempPath("empty.svg").string(), empty), std::runtime_error);
+}
+
+TEST(ExportSvg, ReachableThroughExportModelAndListedAsAnExtension) {
+    const std::vector<std::string>& exts = exportExtensions();
+    EXPECT_NE(std::find(exts.begin(), exts.end(), ".svg"), exts.end());
+
+    const std::string path = tempPath("via_export_model.svg").string();
+    const std::vector<std::string> warnings = exportModel(path, evalToBodies("circle(5, $fn=8);"), ExportOptions{});
+    EXPECT_TRUE(warnings.empty());  // none of the mesh checks apply to contours
+    const std::string text = readText(path);
+    EXPECT_NE(text.find("<svg "), std::string::npos);
+    EXPECT_EQ(countOf(text, "M "), 1u);
+    std::remove(path.c_str());
+}
+
+// Byte-for-byte against real OpenSCAD 2026.02.01's own `-o out.svg` for the
+// same script -- header, vertex order, the 6-vertex line wrap and the "-0"
+// that a negated zero prints as. Contour ORDER (outline before hole) and
+// winding come from Manifold rather than CGAL, so agreeing here is worth
+// pinning: it is the part that could drift without anything else noticing.
+TEST(ExportSvg, MatchesRealOpenscadByteForByte) {
+    const std::string expected =
+        R"SVG(<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg width="42mm" height="27mm" viewBox="-1 -26 42 27" xmlns="http://www.w3.org/2000/svg" version="1.1">
+<title>OpenSCAD Model</title>
+<path d="
+M 40,-25 L 0,-25 L 0,-0 L 40,-0 z
+M 18.0866,-7.3806 L 16.4645,-8.46447 L 15.3806,-10.0866 L 15,-12 L 15.3806,-13.9134 L 16.4645,-15.5355
+ L 18.0866,-16.6194 L 20,-17 L 21.9134,-16.6194 L 23.5355,-15.5355 L 24.6194,-13.9134 L 25,-12
+ L 24.6194,-10.0866 L 23.5355,-8.46447 L 21.9134,-7.3806 L 20,-7 z
+" stroke="black" fill="none" stroke-width="0.35"/>
+</svg>
+)SVG";
+    EXPECT_EQ(svgOf("difference() { square([40,25]); translate([20,12]) circle(5, $fn=16); }", "parity.svg"),
+              expected);
+}

{openscad_cpp_evaluator-1.9.0 → openscad_cpp_evaluator-1.10.0}/tests/test_python_bindings.py

@@ -661,6 +661,46 @@ def test_export_model_facade_accepts_split_components(tmp_path):
     assert objects_in(tmp_path / "split.3mf", split_components=True) == 3
 
 
+def test_export_model_writes_svg_and_takes_its_options(tmp_path):
+    """.svg through the facade, options included -- the same two-parameter-list
+    trap as test_export_model_facade_accepts_split_components."""
+    from openscad_cpp_evaluator import Evaluator, EvalError, export_extensions, export_model
+
+    assert ".svg" in export_extensions()
+
+    src = tmp_path / "flat.scad"
+    src.write_text("square([70.4, 25.3]);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+
+    out = tmp_path / "flat.svg"
+    assert export_model(str(out), ev.geometry) == []
+    text = out.read_text()
+    # Page = bounds + half the stroke, rounded outward; matches OpenSCAD's.
+    assert 'width="72mm" height="27mm" viewBox="-1 -26 72 27"' in text
+    assert 'stroke="black" fill="none" stroke-width="0.35"' in text
+
+    styled = tmp_path / "styled.svg"
+    export_model(str(styled), ev.geometry, svg_stroke=False, svg_fill=True, svg_fill_color="red")
+    styled_text = styled.read_text()
+    assert 'stroke="none" fill="red"' in styled_text
+    # No stroke, no stroke padding -- so the page shrinks.
+    assert 'width="71mm" height="26mm"' in styled_text
+
+
+def test_export_model_svg_refuses_a_3d_model(tmp_path):
+    """OpenSCAD's rule, and ours: 2D export needs an all-2D top level."""
+    import pytest
+    from openscad_cpp_evaluator import Evaluator, EvalError, export_model
+
+    src = tmp_path / "solid.scad"
+    src.write_text("cube(10);")
+    ev = Evaluator()
+    ev.evaluate(str(src), {})
+    with pytest.raises(EvalError, match="not a 2D object"):
+        export_model(str(tmp_path / "solid.svg"), ev.geometry)
+
+
 def test_strict_commas_reaches_the_parser(tmp_path):
     """Evaluator.evaluate(strict_commas=True) must survive both hand-written
     parameter lists -- the facade's and the nanobind binding's. The last