openscad-cpp-evaluator 0.13.9__tar.gz → 0.14.0__tar.gz

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/src/builtins/booleans.cpp

@@ -176,7 +176,23 @@ std::vector<ColoredBody> generateCsg(Evaluator& ev, const CSGParams& params, con
 
         std::vector<ColoredBody> bodies3d, sections2d;
         for (const ColoredBody& c : split.foreground) {
-            if (c.body) bodies3d.push_back(c);
+            // A body whose own Manifold::Status() isn't NoError (e.g.
+            // NonFiniteVertex, from a degenerate accumulated transform deep
+            // in an unrelated ancestor's positioning math -- found via a
+            // real user script, snappy-reprap's z_tower_assembly chain,
+            // where one already-invalid sub-part silently zeroed out an
+            // entire 65-operand union of otherwise-valid geometry) must
+            // never reach Manifold's own `+`/`-`/`^` operators: unlike a
+            // genuinely empty operand (0 triangles, NoError), Manifold
+            // propagates a non-NoError status through boolean ops onto the
+            // WHOLE result instead of treating it as a no-op contributor,
+            // so a single bad part silently discards every valid sibling.
+            // Real OpenSCAD's CGAL backend doesn't hit this at all here
+            // (more robust to the same input) -- dropping the one invalid
+            // operand and unioning everything else is the closest match to
+            // its own behavior available without new numerical-robustness
+            // work on Manifold's own boolean ops.
+            if (c.body && c.body->Status() == manifold::Manifold::Error::NoError) bodies3d.push_back(c);
         }
         for (const ColoredBody& c : split.foreground) {
             if (c.section) sections2d.push_back(c);

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/src/builtins/extrude.cpp

@@ -181,8 +181,19 @@ std::vector<ColoredBody> generateProjection(Evaluator&, const CSGParams& params,
 BuiltinWrapParams computeOffsetParams(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
 
-    const Value rArg = getArg(args, std::nullopt, "r", Value{});
+    // `r` owns position 0 (offset(2) == offset(r=2)); delta/chamfer are
+    // named-only, matching the reference. `r` also wins outright when both
+    // are given -- the reference never even looks at delta in that case.
+    Value rArg = getArg(args, 0, "r", Value{});
     const Value deltaArg = getArg(args, std::nullopt, "delta", Value{});
+    // A bare offset() is offset(r=1), not a pass-through: the reference
+    // initialises delta to 1 with a round join and only ever overwrites it
+    // from an argument, so "neither given" lands on the same state "r=1"
+    // does. Verified against OpenSCAD 2022.08.22 -- offset() and offset(r=1)
+    // produce a byte-identical mesh for the same input.
+    if (std::holds_alternative<std::monostate>(rArg) && std::holds_alternative<std::monostate>(deltaArg)) {
+        rArg = Value{1.0};
+    }
     const bool chamfer = truthy(getArg(args, std::nullopt, "chamfer", Value{false}));
 
     CSGParams params;

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/src/builtins/function_builtins.cpp

@@ -279,7 +279,13 @@ Value builtinSearch(const CallArgs& args) {
 }
 
 Value builtinLookup(const CallArgs& args) {
-    const double key = toDoubleLenient(getArg(args, 0, "key", Value{}));
+    // Guarded here rather than via scalarNumericArity() -- the second
+    // argument is a table, so the all-arguments-are-numbers rule can't
+    // apply. Without this, toDoubleLenient() turns a non-numeric key into
+    // 0.0 and the lookup silently returns the table's first value.
+    const Value keyArg = getArg(args, 0, "key", Value{});
+    if (!std::holds_alternative<double>(keyArg)) return Value{};
+    const double key = std::get<double>(keyArg);
     const Value tableArg = getArg(args, 1, "table", Value{});
     const ListPtr* tablePtr = std::get_if<ListPtr>(&tableArg);
     if (!tablePtr || !*tablePtr) return Value{};
@@ -359,11 +365,35 @@ Value builtinFontmetrics(Evaluator& ev, const CallArgs& args) {
     });
 }
 
-const std::unordered_set<std::string>& numericOnlyNames() {
-    static const std::unordered_set<std::string> names = {
-        "abs", "sign", "ceil", "floor", "round", "sqrt", "ln", "log", "exp", "sin", "cos", "tan",
-        "asin", "acos", "atan", "atan2", "pow", "max", "min", "norm", "cross",
+// Take only scalar numbers, mapped to how many leading positional
+// arguments must each actually BE a number. Anything else there (undef, a
+// string, a list, a bool, an object) is a type error yielding undef, and
+// so is supplying fewer arguments than the arity -- matching the
+// reference, which rejects the call outright rather than coercing.
+//
+// This has to be checked up front rather than left to each case below:
+// toDoubleLenient() silently turns undef/string/list into 0.0, which
+// would make `cos(misspelled_var)` quietly 1 instead of undef, and a
+// typo'd variable then produces plausible-looking geometry instead of an
+// obvious failure. Arity is deliberately a floor, not an exact match --
+// the reference also rejects EXTRA arguments, but tightening that too
+// risks breaking working library code for no correctness gain here.
+const std::unordered_map<std::string, size_t>& scalarNumericArity() {
+    static const std::unordered_map<std::string, size_t> arity = {
+        {"abs", 1}, {"sign", 1}, {"ceil", 1}, {"floor", 1}, {"round", 1}, {"sqrt", 1},
+        {"ln", 1}, {"log", 1}, {"exp", 1}, {"sin", 1}, {"cos", 1}, {"tan", 1},
+        {"asin", 1}, {"acos", 1}, {"atan", 1}, {"atan2", 2}, {"pow", 2}, {"rands", 3},
     };
+    return arity;
+}
+
+// Numeric functions that legitimately take a LIST argument, so the
+// all-arguments-must-be-numbers rule above can't apply -- each validates
+// its own operands, and only needs the bool case caught here (Value's
+// bool and double are distinct alternatives, but the reference rejects
+// `max(true, 1)` as a type error rather than treating true as 1).
+const std::unordered_set<std::string>& numericOnlyNames() {
+    static const std::unordered_set<std::string> names = {"max", "min", "norm", "cross"};
     return names;
 }
 
@@ -479,7 +509,13 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
     // elsewhere before reaching here) -- mirrors the old chain's fallthrough.
     if (idIt == ids.end()) return Value{};
 
-    if (numericOnlyNames().count(name)) {
+    if (const auto arityIt = scalarNumericArity().find(name); arityIt != scalarNumericArity().end()) {
+        const std::vector<Value> positional = allPositional(args);
+        if (positional.size() < arityIt->second) return Value{};
+        for (size_t i = 0; i < arityIt->second; ++i) {
+            if (!std::holds_alternative<double>(positional[i])) return Value{};
+        }
+    } else if (numericOnlyNames().count(name)) {
         for (const Value& v : allPositional(args)) {
             if (isBoolOrListContainsBool(v)) return Value{};
         }

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/src/builtins/primitives_3d.cpp

@@ -144,34 +144,38 @@ std::vector<ColoredBody> generateSphere(Evaluator& ev, const CSGParams& params,
 CSGParams resolveCylinder(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
     auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
     const double h = toDoubleLenient(getArg(args, 0, "h", Value{1.0}));
-    Value rV = getArg(args, 1, "r", Value{});
-    Value r1V = getArg(args, std::nullopt, "r1", Value{});
-    Value r2V = getArg(args, std::nullopt, "r2", Value{});
+    // Positional order is (h, r1, r2, center); r/d/d1/d2 are named-only.
+    // NOTE r1/r2 -- not r -- own positions 1 and 2, so `cylinder(10, 5, 2)`
+    // is a cone, and `cylinder(10, 5)` is a cone tapering to the r2 default
+    // of 1 rather than a straight r=5 cylinder. Both match the reference.
+    Value rV = getArg(args, std::nullopt, "r", Value{});
     Value dV = getArg(args, std::nullopt, "d", Value{});
+    Value r1V = getArg(args, 1, "r1", Value{});
+    Value r2V = getArg(args, 2, "r2", Value{});
     Value d1V = getArg(args, std::nullopt, "d1", Value{});
     Value d2V = getArg(args, std::nullopt, "d2", Value{});
-    const bool center = truthy(getArg(args, std::nullopt, "center", Value{false}));
-
-    std::optional<double> r = isUndef(rV) ? std::nullopt : std::optional<double>(toDoubleLenient(rV));
-    std::optional<double> r1 = isUndef(r1V) ? std::nullopt : std::optional<double>(toDoubleLenient(r1V));
-    std::optional<double> r2 = isUndef(r2V) ? std::nullopt : std::optional<double>(toDoubleLenient(r2V));
-
-    if (!isUndef(dV) && !r) r = toDoubleLenient(dV) / 2.0;
-    if (!isUndef(d1V) && !r1) r1 = toDoubleLenient(d1V) / 2.0;
-    if (!isUndef(d2V) && !r2) r2 = toDoubleLenient(d2V) / 2.0;
-    if (r) {
-        r1 = *r;
-        r2 = *r;
-    }
-    if (!r1) r1 = 1.0;
-    if (!r2) r2 = *r1;
-
-    const int segs = fnSegmentsFromCtx(effCtx, std::max(*r1, *r2));
+    const bool center = truthy(getArg(args, 3, "center", Value{false}));
+
+    // Application order is significant and mirrors the reference's own
+    // sequence of independent `if (x.isNumber()) ...` assignments: r, then
+    // d (which overrides r outright rather than deferring to it), then the
+    // per-end r1/r2, then the per-end d1/d2. So `cylinder(h=10, d=8, r1=5)`
+    // is r1=5/r2=4, and `cylinder(h=10, r=5, r2=2)` is r1=5/r2=2. Both ends
+    // default to 1 independently -- r2 does NOT fall back to r1.
+    double r1 = 1.0, r2 = 1.0;
+    if (!isUndef(rV)) r1 = r2 = toDoubleLenient(rV);
+    if (!isUndef(dV)) r1 = r2 = toDoubleLenient(dV) / 2.0;
+    if (!isUndef(r1V)) r1 = toDoubleLenient(r1V);
+    if (!isUndef(r2V)) r2 = toDoubleLenient(r2V);
+    if (!isUndef(d1V)) r1 = toDoubleLenient(d1V) / 2.0;
+    if (!isUndef(d2V)) r2 = toDoubleLenient(d2V) / 2.0;
+
+    const int segs = fnSegmentsFromCtx(effCtx, std::max(r1, r2));
 
     CSGParams params;
     params["h"] = Value{h};
-    params["r1"] = Value{*r1};
-    params["r2"] = Value{*r2};
+    params["r1"] = Value{r1};
+    params["r2"] = Value{r2};
     params["center"] = Value{center};
     params["segs"] = Value{static_cast<double>(segs)};
     params["color"] = colorToValue(effCtx.color);

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/src/builtins/transforms.cpp

@@ -3,6 +3,7 @@
 #include "openscad_cpp_evaluator/call_args.hpp"
 #include "openscad_cpp_evaluator/evaluator.hpp"
 
+#include <array>
 #include <cmath>
 #include <numbers>
 
@@ -32,6 +33,21 @@ manifold::vec2 toVec2(const Value& v, double defaultX = 0.0, double defaultY = 0
     return manifold::vec2(defaultX, defaultY);
 }
 
+// resize()'s `auto` argument: a bare bool applies to all three axes, a
+// list applies element-wise (missing elements are false), anything else
+// (including undef) disables auto entirely. Mirrors the reference's
+// Value::toBool()/vector handling.
+std::array<bool, 3> toAutoAxes(const Value& v) {
+    if (const bool* b = std::get_if<bool>(&v)) return {*b, *b, *b};
+    if (const ListPtr* l = std::get_if<ListPtr>(&v); l && *l) {
+        const auto& items = (*l)->items;
+        std::array<bool, 3> out{false, false, false};
+        for (size_t i = 0; i < 3 && i < items.size(); ++i) out[i] = truthy(items[i]);
+        return out;
+    }
+    return {false, false, false};
+}
+
 // Rodrigues' rotation formula as a 3x4 transform (rotate(angle, axis) --
 // the axis form, as opposed to rotate([x,y,z]) Euler angles, which uses
 // Manifold's own Rotate() directly and never needs this). Mirrors
@@ -117,13 +133,35 @@ manifold::Manifold applyTransform3d(const std::string& name, const CallArgs& arg
         return body.Mirror(toVec3(getArg(args, 0, "v", Value{}), 1.0, 0.0, 0.0));
     }
     if (name == "resize") {
-        const manifold::vec3 newSize = toVec3(getArg(args, 0, "newsize", Value{}));
+        const manifold::vec3 newSizeV = toVec3(getArg(args, 0, "newsize", Value{}));
+        std::array<bool, 3> autoAxes = toAutoAxes(getArg(args, 1, "auto", Value{}));
         const manifold::Box bbox = body.BoundingBox();
-        const manifold::vec3 span = bbox.max - bbox.min;
-        const double sx = (newSize.x != 0.0 && span.x != 0.0) ? newSize.x / span.x : 1.0;
-        const double sy = (newSize.y != 0.0 && span.y != 0.0) ? newSize.y / span.y : 1.0;
-        const double sz = (newSize.z != 0.0 && span.z != 0.0) ? newSize.z / span.z : 1.0;
-        return body.Scale(manifold::vec3(sx, sy, sz));
+        const manifold::vec3 spanV = bbox.max - bbox.min;
+        const double ns[3] = {newSizeV.x, newSizeV.y, newSizeV.z};
+        const double span[3] = {spanV.x, spanV.y, spanV.z};
+
+        // An `auto` axis takes the scale factor of whichever axis asked for
+        // the LARGEST new size -- not its own (it has none) and not the
+        // first specified one. Mirrors the reference's newsizemax_index:
+        // ties keep the earlier axis, and an all-zero newsize leaves the
+        // factor at 1 so `resize([0,0,0], true)` is a no-op.
+        int maxIdx = 0;
+        for (int i = 1; i < 3; ++i) {
+            if (ns[i] > ns[maxIdx]) maxIdx = i;
+        }
+        const double autoScale = (ns[maxIdx] != 0.0 && span[maxIdx] != 0.0) ? ns[maxIdx] / span[maxIdx] : 1.0;
+
+        double scale[3];
+        for (int i = 0; i < 3; ++i) {
+            if (ns[i] != 0.0 && span[i] != 0.0) {
+                scale[i] = ns[i] / span[i];
+            } else if (ns[i] == 0.0 && autoAxes[static_cast<size_t>(i)]) {
+                scale[i] = autoScale;
+            } else {
+                scale[i] = 1.0;
+            }
+        }
+        return body.Scale(manifold::vec3(scale[0], scale[1], scale[2]));
     }
     if (name == "multmatrix") {
         Value m = getArg(args, 0, "m", Value{});

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/tests/test_booleans.cpp

@@ -87,6 +87,25 @@ TEST(Difference, EmptySubtractorLeavesBaseUnchanged) {
     EXPECT_NEAR(e.bodies[0].body->Volume(), 64.0, 1e-6);
 }
 
+TEST(Union, OneInvalidOperandDoesNotDiscardValidSiblings) {
+    // Regression: Manifold's own `+` propagates a non-NoError Status()
+    // (e.g. NonFiniteVertex, from a degenerate NaN-vertex polyhedron here --
+    // in the wild, from an accumulated transform deep in an unrelated
+    // ancestor's own positioning math) onto the WHOLE combined result
+    // instead of treating the bad operand as a no-op contributor. Before
+    // filtering invalid operands out in generateCsg, a single bad part
+    // anywhere in a many-operand union() silently discarded every valid
+    // sibling too -- found via a real user project (snappy-reprap) where
+    // this zeroed out an entire ~65-part extruder assembly with no warning.
+    Evaluated e = evalSrc("union() {"
+                          "  polyhedron(points=[[0,0,0],[2,0,0],[0,2,0],[0/0,0,2]],"
+                          "             faces=[[0,1,2],[0,3,1],[0,2,3],[1,3,2]]);"
+                          "  translate([10,0,0]) cube(2);"
+                          "}");
+    ASSERT_EQ(e.bodies.size(), 1u);
+    EXPECT_NEAR(e.bodies[0].body->Volume(), 8.0, 1e-6); // just the valid cube -- the NaN polyhedron is dropped, not fatal
+}
+
 // -- 2D-native boolean CSG (union/difference/intersection applied directly
 // to 2D children, not mediated through linear_extrude()) -----------------
 

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/tests/test_extrude_roof.cpp

@@ -151,11 +151,27 @@ TEST(Offset, NegativeDeltaShrinksTheSquare) {
     EXPECT_NEAR(e.bodies[0].section->Area(), 2.0 * 2.0, 1e-6);
 }
 
-TEST(Offset, NoRadiusOrDeltaPassesThroughFirstChild) {
-    Evaluated e = evalSrc("offset() square(4, center=true);");
-    ASSERT_EQ(e.bodies.size(), 1u);
-    ASSERT_TRUE(e.bodies[0].section.has_value());
-    EXPECT_NEAR(e.bodies[0].section->Area(), 16.0, 1e-6);
+// `r` owns position 0, so offset(2) == offset(r=2). It used to be
+// named-only, making a bare offset(2) a silent no-op.
+TEST(Offset, FirstPositionalArgumentIsRadius) {
+    Evaluated positional = evalSrc("offset(1, $fn=64) square(4, center=true);");
+    Evaluated named = evalSrc("offset(r=1, $fn=64) square(4, center=true);");
+    ASSERT_TRUE(positional.bodies[0].section.has_value());
+    EXPECT_NEAR(positional.bodies[0].section->Area(), named.bodies[0].section->Area(), 1e-9);
+    EXPECT_GT(positional.bodies[0].section->Area(), 16.0);
+}
+
+// A bare offset() is offset(r=1), NOT a pass-through -- the reference
+// initialises its delta to 1 with a round join and only overwrites it from
+// an argument. Verified against OpenSCAD 2022.08.22, where offset() and
+// offset(r=1) produce identical geometry.
+TEST(Offset, NoRadiusOrDeltaDefaultsToRadiusOne) {
+    Evaluated bare = evalSrc("offset() square(4, center=true);");
+    Evaluated explicitR = evalSrc("offset(r=1) square(4, center=true);");
+    ASSERT_EQ(bare.bodies.size(), 1u);
+    ASSERT_TRUE(bare.bodies[0].section.has_value());
+    EXPECT_NEAR(bare.bodies[0].section->Area(), explicitR.bodies[0].section->Area(), 1e-9);
+    EXPECT_GT(bare.bodies[0].section->Area(), 16.0); // grew, rather than passing through
 }
 
 // -- roof -----------------------------------------------------------------

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/tests/test_function_builtins.cpp

@@ -96,6 +96,56 @@ TEST(MathBuiltins, BoolArgumentIsUndefForNumericOnlyFns) {
     EXPECT_TRUE(isUndef(evalSrc("norm([true, 0])", ev)));
 }
 
+// Every scalar-numeric builtin rejects a non-number argument outright
+// rather than coercing it through toDoubleLenient()'s 0.0. Each expected
+// value below was confirmed against real OpenSCAD 2022.08.22, which warns
+// ("parameter could not be converted") and yields undef. Before this,
+// `cos(undef)` was 1, `ln(undef)` was -inf and `acos([1,2])` was 90 --
+// a misspelled variable produced plausible geometry instead of failing.
+TEST(MathBuiltins, NonNumericArgumentIsUndefForScalarNumericFns) {
+    Evaluator ev;
+    for (const char* fn : {"abs", "sign", "ceil", "floor", "round", "sqrt", "ln", "log", "exp",
+                           "sin", "cos", "tan", "asin", "acos", "atan"}) {
+        const std::string f(fn);
+        EXPECT_TRUE(isUndef(evalSrc(f + "(undef)", ev))) << f << "(undef)";
+        EXPECT_TRUE(isUndef(evalSrc(f + "(\"hi\")", ev))) << f << "(\"hi\")";
+        EXPECT_TRUE(isUndef(evalSrc(f + "([1,2])", ev))) << f << "([1,2])";
+        EXPECT_TRUE(isUndef(evalSrc(f + "(true)", ev))) << f << "(true)";
+    }
+    EXPECT_TRUE(isUndef(evalSrc("atan2(1, undef)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("atan2(undef, 1)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("pow(2, undef)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("pow(undef, 2)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("rands(undef, 1, 3, 42)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("rands(0, 1, undef, 42)", ev)));
+    // lookup() can't use the same rule (its second argument is a table),
+    // so it guards its key separately -- without that, a non-numeric key
+    // became 0.0 and silently returned the table's first value.
+    EXPECT_TRUE(isUndef(evalSrc("lookup(undef, [[0,1],[10,5]])", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("lookup(5, undef)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("lookup(5, \"hi\")", ev)));
+}
+
+// Too few arguments is a type error too, not a call against an implicit 0.
+TEST(MathBuiltins, MissingArgumentIsUndefForScalarNumericFns) {
+    Evaluator ev;
+    EXPECT_TRUE(isUndef(evalSrc("abs()", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("pow(2)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("atan2(1)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("rands(0, 1)", ev)));
+}
+
+// The guard must not disturb the functions that legitimately take lists.
+TEST(MathBuiltins, ListAcceptingNumericFnsStillWork) {
+    Evaluator ev;
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("max([4,9,2])", ev)), 9.0);
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("min([4,9,2])", ev)), 2.0);
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("norm([3,4])", ev)), 5.0);
+    EXPECT_DOUBLE_EQ(asNum(evalSrc("lookup(5, [[0,5],[10,8],[20,2]])", ev)), 6.5);
+    EXPECT_TRUE(isUndef(evalSrc("max(undef, 1)", ev)));
+    EXPECT_TRUE(isUndef(evalSrc("norm(undef)", ev)));
+}
+
 TEST(MathBuiltins, Rands) {
     Evaluator ev;
     Value v = evalSrc("rands(1, 2, 5, 42)", ev);

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/tests/test_primitives.cpp

@@ -78,10 +78,47 @@ TEST(Cylinder, NoRadiusArgumentAtAllDefaultsToRadiusOne) {
     EXPECT_NEAR(withNoArgs.bodies[0].body->Volume(), withExplicitR.bodies[0].body->Volume(), 1e-9);
 }
 
-TEST(Cylinder, R1OnlyDefaultsR2ToR1) {
+// r2 does NOT fall back to r1 -- each end defaults to 1 on its own, so
+// `cylinder(h, r1=3)` is a cone tapering 3 -> 1, not a straight r=3
+// cylinder. Verified against OpenSCAD 2022.08.22 (rbot 3, rtop 1).
+TEST(Cylinder, R1OnlyLeavesR2AtItsOwnDefaultOfOne) {
     Evaluated withR1Only = evalSrc("cylinder(h=5, r1=3, $fn=16);");
-    Evaluated withBoth = evalSrc("cylinder(h=5, r1=3, r2=3, $fn=16);");
-    EXPECT_NEAR(withR1Only.bodies[0].body->Volume(), withBoth.bodies[0].body->Volume(), 1e-9);
+    Evaluated asCone = evalSrc("cylinder(h=5, r1=3, r2=1, $fn=16);");
+    Evaluated asStraight = evalSrc("cylinder(h=5, r1=3, r2=3, $fn=16);");
+    EXPECT_NEAR(withR1Only.bodies[0].body->Volume(), asCone.bodies[0].body->Volume(), 1e-9);
+    EXPECT_GT(std::abs(withR1Only.bodies[0].body->Volume() - asStraight.bodies[0].body->Volume()), 1.0);
+}
+
+// Positional order is (h, r1, r2, center) -- position 1 is r1, not r, so a
+// third positional argument really does make a cone and a fourth really
+// does centre it. This is the arg-order bug that made `cylinder(10, 5, 2)`
+// silently render as a straight r=5 cylinder.
+TEST(Cylinder, PositionalArgsAreHR1R2Center) {
+    Evaluated positional = evalSrc("cylinder(10, 5, 2, true, $fn=16);");
+    Evaluated named = evalSrc("cylinder(h=10, r1=5, r2=2, center=true, $fn=16);");
+    EXPECT_NEAR(positional.bodies[0].body->Volume(), named.bodies[0].body->Volume(), 1e-9);
+    const manifold::Box bb = positional.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bb.min.z, -5.0, 1e-9);
+    EXPECT_NEAR(bb.max.z, 5.0, 1e-9);
+}
+
+// Application order: r, then d (which overrides r outright), then r1/r2,
+// then d1/d2. Each verified against OpenSCAD 2022.08.22.
+TEST(Cylinder, DiameterAndRadiusOverrideOrderMatchesReference) {
+    // d=8 sets both ends to 4; the explicit r1=5 then overrides the bottom.
+    Evaluated dThenR1 = evalSrc("cylinder(h=10, d=8, r1=5, $fn=16);");
+    Evaluated expected1 = evalSrc("cylinder(h=10, r1=5, r2=4, $fn=16);");
+    EXPECT_NEAR(dThenR1.bodies[0].body->Volume(), expected1.bodies[0].body->Volume(), 1e-9);
+
+    // r=5 sets both ends; the explicit r2=2 then overrides the top.
+    Evaluated rThenR2 = evalSrc("cylinder(h=10, r=5, r2=2, $fn=16);");
+    Evaluated expected2 = evalSrc("cylinder(h=10, r1=5, r2=2, $fn=16);");
+    EXPECT_NEAR(rThenR2.bodies[0].body->Volume(), expected2.bodies[0].body->Volume(), 1e-9);
+
+    // d wins over r outright rather than deferring to it.
+    Evaluated dWinsOverR = evalSrc("cylinder(h=10, r=5, d=8, $fn=16);");
+    Evaluated expected3 = evalSrc("cylinder(h=10, r=4, $fn=16);");
+    EXPECT_NEAR(dWinsOverR.bodies[0].body->Volume(), expected3.bodies[0].body->Volume(), 1e-9);
 }
 
 // -- polyhedron -----------------------------------------------------------

{openscad_cpp_evaluator-0.13.9 → openscad_cpp_evaluator-0.14.0}/tests/test_transforms.cpp

@@ -150,6 +150,56 @@ TEST(Resize, ZeroComponentLeavesThatAxisUnscaled) {
     EXPECT_NEAR(bbox.max.z, 1.0, 1e-9); // unscaled
 }
 
+// `auto` scales the zero-valued axes by the factor of whichever axis asked
+// for the LARGEST new size. Every expectation below was confirmed against
+// real OpenSCAD 2022.08.22; before this, `auto` was accepted and ignored.
+TEST(Resize, AutoScalesZeroAxesByTheLargestRequestedAxisFactor) {
+    // Bare `true` covers all three axes: 20/5 = 4x on X, so Y and Z too.
+    Evaluated allAxes = evalSrc("resize([20,0,0], true) cube(5);");
+    manifold::Box bbox = allAxes.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bbox.max.x, 20.0, 1e-9);
+    EXPECT_NEAR(bbox.max.y, 20.0, 1e-9);
+    EXPECT_NEAR(bbox.max.z, 20.0, 1e-9);
+
+    // Named form is identical to the positional one.
+    Evaluated named = evalSrc("resize([20,0,0], auto=true) cube(5);");
+    manifold::Box nbox = named.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(nbox.max.y, 20.0, 1e-9);
+
+    // A per-axis list only auto-scales the axes it names.
+    Evaluated perAxis = evalSrc("resize([20,0,0], [false,true,false]) cube(5);");
+    manifold::Box pbox = perAxis.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(pbox.max.x, 20.0, 1e-9);
+    EXPECT_NEAR(pbox.max.y, 20.0, 1e-9);
+    EXPECT_NEAR(pbox.max.z, 5.0, 1e-9); // not auto -- left alone
+}
+
+TEST(Resize, AutoFactorComesFromTheLargestNewsizeNotTheFirst) {
+    // span (5,10,20); newsize (20,30,0). The largest requested size is 30
+    // on Y, so the auto Z axis scales by 30/10 = 3 -> 60, NOT by X's 20/5.
+    Evaluated e = evalSrc("resize([20,30,0], true) cube([5,10,20]);");
+    manifold::Box bbox = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bbox.max.x, 20.0, 1e-9);
+    EXPECT_NEAR(bbox.max.y, 30.0, 1e-9);
+    EXPECT_NEAR(bbox.max.z, 60.0, 1e-9);
+}
+
+TEST(Resize, AutoWithNoRequestedSizeIsANoOp) {
+    Evaluated e = evalSrc("resize([0,0,0], true) cube(5);");
+    manifold::Box bbox = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bbox.max.x, 5.0, 1e-9);
+    EXPECT_NEAR(bbox.max.y, 5.0, 1e-9);
+    EXPECT_NEAR(bbox.max.z, 5.0, 1e-9);
+}
+
+TEST(Resize, AutoFalseLeavesZeroAxesUnscaled) {
+    Evaluated e = evalSrc("resize([20,0,0], false) cube(5);");
+    manifold::Box bbox = e.bodies[0].body->BoundingBox();
+    EXPECT_NEAR(bbox.max.x, 20.0, 1e-9);
+    EXPECT_NEAR(bbox.max.y, 5.0, 1e-9);
+    EXPECT_NEAR(bbox.max.z, 5.0, 1e-9);
+}
+
 // -- 2D transform dispatch (a transform's child is a CrossSection, not a
 // Manifold -- resolved per-body at generate time) ---------------------------
 

openscad_cpp_evaluator-0.14.0/uv.lock

@@ -0,0 +1,65 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "numpy"
+version = "2.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" },
+    { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" },
+    { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" },
+    { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" },
+    { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" },
+    { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" },
+    { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" },
+    { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" },
+    { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" },
+    { url = "https://files.pythonhosted.org/packages/db/f4/731b6085a83faf6ca843394cbd5e217280c214399f7e8b21b9f552af0ae2/numpy-2.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7c786fe9a5bbe360022e584c5a34cf6b54265c71bd7ec8ac3d8fec38968071f8", size = 16795063, upload-time = "2026-07-04T17:07:07.374Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/64/0e215f2048dd11a55bb989ed41b3585ef57452404e638d703a211a3e4157/numpy-2.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32985c896d897419ef8da6917872d80b78ad0ea26d85b23245c7366ffde76d75", size = 11776652, upload-time = "2026-07-04T17:07:09.907Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/59/2b844c7a6e9deff69b404a66221e1542937734f65d5e6e39411876053862/numpy-2.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:efd736408cc97c79b9e6917338dfc8f06013b2274f992e96b1d9a81a71e2a2c2", size = 5335944, upload-time = "2026-07-04T17:07:12.227Z" },
+    { url = "https://files.pythonhosted.org/packages/86/51/9bf7cb2cabcebc9e017e4ec7e6322b378317a542c08b4cb68479c1efc716/numpy-2.5.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ab84dc6b074fa881cae55bea94cc4f68e285181ba7f32497bf7dee6b1496165b", size = 6656266, upload-time = "2026-07-04T17:07:14.368Z" },
+    { url = "https://files.pythonhosted.org/packages/83/3e/fb7615b211b82a32f44d5180a6d421b61f84d4fadd578b48ba4ac34e189f/numpy-2.5.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caf3e317d33d60c37986b452613f4ab51246d0691350c03d0cb4a898627f4a95", size = 15179720, upload-time = "2026-07-04T17:07:16.272Z" },
+    { url = "https://files.pythonhosted.org/packages/41/5f/0f992cb24560673496c5d68de61913b57166ce530ffda07c1f280e0cc464/numpy-2.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54ad769f17bc2d833b620851989f62054fb9ab93c969d9e1dc3c8e3d56beea21", size = 16664835, upload-time = "2026-07-04T17:07:19.021Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2f/97d6475ee91afe2587797d09446f9d3e475ad4cb681662d824809327b75a/numpy-2.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c12afb53450fa976d4c681c50a7423729a4c51c0465ed9f32b8a9cabbc472373", size = 16539135, upload-time = "2026-07-04T17:07:22.015Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/5b/4db81e4ba0be7e2776b1de68c82aa862c7f8ec27e1b4927d4ae075e20678/numpy-2.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c11c405efc5ff6816d5983c96cdfa215bab3428961243af3ff59b228490438", size = 18426684, upload-time = "2026-07-04T17:07:24.941Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/64/c0ba2d90724d450279a7df8f32057241070250a26a7e2b5337d77347f481/numpy-2.5.1-cp314-cp314-win32.whl", hash = "sha256:f2479a47f8d5932d1718168a681ad6e536a9df484c83cfcf9de365e164537ace", size = 6116103, upload-time = "2026-07-04T17:07:27.622Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/1a/837f9ed7405adcd7a40538792eb169eddd8fa5630c16a1ef49dae71a30f4/numpy-2.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:24d0eb82c0541d3415a33425db64ae439dffccd7b4dbcb30e7c35120205c506a", size = 12562177, upload-time = "2026-07-04T17:07:29.887Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ed/49707938b6dd0a78a9178dd93227dc89e4c11af47f5c798d70366e8d0483/numpy-2.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5a4c988b38d261deeeaad9954e3deb091ad905c94e8bb6708654ef1d97f286b0", size = 10627739, upload-time = "2026-07-04T17:07:32.568Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/c7/bb4b882cfe7f299cbc8b66e42e7dd78cf9d14e40f9469fc5e3db7e15b3bd/numpy-2.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a33276be12fa045805f477f22482088b66bb758ffbe89a9d21457de863a32e22", size = 11894709, upload-time = "2026-07-04T17:07:34.941Z" },
+    { url = "https://files.pythonhosted.org/packages/40/3f/5af7f4a7f6224aef48017aa82bb6174c7a659d724be0c75017b7e64a55b4/numpy-2.5.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f089d7b00756190aacf1f5d34bdf38c3c430ac82b4f868f8cede73380460fce7", size = 5453810, upload-time = "2026-07-04T17:07:37.495Z" },
+    { url = "https://files.pythonhosted.org/packages/20/c9/3474309bc94d634d3f9c3eddf03250ecb8c22cd948ef16fef69a77cc5d7b/numpy-2.5.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:09e9bfd8d2cf479c7d174804fb3811c53a8e9f20a37444008606b57d6b7a826d", size = 6761189, upload-time = "2026-07-04T17:07:39.563Z" },
+    { url = "https://files.pythonhosted.org/packages/90/8a/558ae39fdd55d7e7f7fef9a84a6e964ac6b23edbd2a07e52bb084500507d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e68d8dd1e7eba712948f2053a29ec86917bc70ba1358df869d9f06649ef9cf09", size = 15225039, upload-time = "2026-07-04T17:07:41.682Z" },
+    { url = "https://files.pythonhosted.org/packages/63/27/ca7392b2d030277bdf0273e7d23255b3ee57d57a7c170a6f4fb3981e1e5d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99d5095fa265a0c4152e7bb12759e14381ef5496152f1ce58f44bdf55c44beb4", size = 16701306, upload-time = "2026-07-04T17:07:44.611Z" },
+    { url = "https://files.pythonhosted.org/packages/02/42/03d53ae7996c44d4374a8262e9dc41671fd56cbb98f7d47ef85cf5da4c6b/numpy-2.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab87a91b3cc3382b8956095bd8f95e00cf679bb81554339be1a2ba404a1473c1", size = 16589955, upload-time = "2026-07-04T17:07:47.694Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/15/6c1784ae469640e65db111e9a34b3d0f14d91e8a38b9ce34810ced370dbb/numpy-2.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:224ca51130ef7da85bea2191625181cb4f337f9cb64b471f10c1a12aa8b60077", size = 18464252, upload-time = "2026-07-04T17:07:50.684Z" },
+    { url = "https://files.pythonhosted.org/packages/94/a8/f98e50356cf167df656c526c2dfeec2d7dde182f2a3da4b458a5938e2776/numpy-2.5.1-cp314-cp314t-win32.whl", hash = "sha256:6eab239876581b2b3c5a242281b6007bbdbcd1c7085d7709bb57c5929b11e6bf", size = 6263298, upload-time = "2026-07-04T17:07:53.445Z" },
+    { url = "https://files.pythonhosted.org/packages/72/ac/96ae880cdecad0b3275d9359fcec72667b49a4863c9f12942e43679dda02/numpy-2.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:83ce9c80d5b521b0d77ddcbe5447c218d247929b6cc056ca5351342accfff0af", size = 12748623, upload-time = "2026-07-04T17:07:55.384Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5a/4d2b1601df3602dba7a14f3348ba9bfe94a18adb428e693df6154c293831/numpy-2.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:5a6db61f9aaa57e369905c67d852045d3c4f7126405b29d09b19dec118e9c9cb", size = 10697674, upload-time = "2026-07-04T17:07:58.506Z" },
+]
+
+[[package]]
+name = "openscad-cpp-evaluator"
+version = "0.13.0"
+source = { editable = "." }
+dependencies = [
+    { name = "numpy" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "numpy" }]