openscad-cpp-evaluator 0.45.1__tar.gz → 0.47.0__tar.gz

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/CLAUDE.md

@@ -45,9 +45,13 @@ comprehension clause kinds, user function calls (recursion, defaults, `FunctionL
 user module calls (`children()`/`children(N)`, closure detection via `callCtxFor`), list
 indexing/swizzle member access; the full math/string/list/type-check builtin *function* dispatch
 (`sin`/`cos`/`pow`/`search`/`lookup`/`chr`/`ord`/`is_*`/`object`/`has_key`/etc, ~43 names — a
-completely separate namespace/precedence rule from the builtin *modules* in `registry.cpp`: a
-builtin function name always wins over a same-named user function, checked *before* the
-user-function lookup), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
+same precedence rule as the builtin *modules* in `registry.cpp`: a user-defined function
+**shadows** a same-named builtin, looked up *before* the builtin table. This was backwards until
+0.47.0 — the port copied the old Python evaluator's `_eval_function_call` order, which had it
+wrong; OpenSCAD 2026.02.01 echoes 999 for `function abs(x)=999; abs(-3)` and we echoed 3. Fixing
+it needs **both** resolution sites: `evalFunctionCall` (`user_calls.cpp`) and the compiler's
+call-site resolution (`bytecode_compiler.cpp`), which bakes builtin-vs-user in at compile time,
+plus gating the silent `is_undef` probe on the call actually resolving to the builtin), STL/OBJ/OFF/3MF `import()` in both module (geometry) and expression
 (VNF/JSON) contexts, and 3MF read/write; (Phase 6) `hull()`/`minkowski()` (transparent-splice
 CSG-tree shape like union/difference/intersection, role-split via the shared `splitByRole`),
 `linear_extrude()`/`rotate_extrude()`/`projection(cut=)`, and `roof()`; and (Phase 7) `offset()`,
@@ -711,8 +715,17 @@ 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` — binary STL, OBJ, OFF, and 3MF
-  writers (compose every body into one solid first; 3MF via `zip_stored.hpp`'s `writeDeflateZip`).
+- `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
+  `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`
+  could be written by neither the GUI nor the CLI while every test passed.
+  Colour is carried by 3MF, AMF, OBJ (companion `.mtl`), PLY, VRML and X3D; STL and OFF compose
+  every body into one solid and store geometry only. **AMF** puts colour on the `<volume>` rather
+  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.
   `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`

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/PKG-INFO

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

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/bindings/module.cpp

@@ -786,6 +786,10 @@ NB_MODULE(_openscad_cpp_evaluator, m) {
           "logging them. Raises RuntimeError when there is no geometry, the format is unknown, or the "
           "file cannot be opened.");
 
+    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,
           "Evaluate a .scad file; return (bodies, echoes, id_to_node, csg_tree, profile_result, dyn, dyn_explicit).");

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/include/openscad_cpp_evaluator/export.hpp

@@ -97,6 +97,13 @@ void writeVrml(const std::string& path, const std::vector<ExportObject>& objects
 // Color) and Shape level 1 (Appearance, Material), exactly the nodes used.
 void writeX3d(const std::string& path, const std::vector<ExportObject>& objects);
 
+// AMF 1.1. XML like X3D, but its colour lives on the <volume>, not the
+// face: a mesh holds one vertex list and one <volume> per material. An
+// object whose triangles are not all one colour therefore becomes several
+// volumes -- which is what a multimaterial slicer reads as separate
+// materials to assign to tools.
+void writeAmf(const std::string& path, const std::vector<ExportObject>& objects);
+
 // OFF (Object File Format): header "OFF", "$verts $tris 0", vertex lines,
 // then "3 i j k" per triangle (0-indexed, count-prefixed). Mirrors
 // export.py's write_off.

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/pyproject.toml

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

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/python/openscad_cpp_evaluator/__init__.py

@@ -315,8 +315,14 @@ def export_model(path: str, geometry, format: str = "", ascii_stl: bool = False,
 
 
 def export_extensions() -> list:
-    """The file extensions export_model understands, dot-prefixed."""
-    return [".3mf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"]
+    """The file extensions export_model understands, dot-prefixed.
+
+    Asked of the extension rather than restated here. The hardcoded copy
+    this replaces had already drifted: it was missing formats the C++
+    writer table had gained, and nothing failed -- callers simply could
+    not reach them.
+    """
+    return list(_ext.export_extensions())
 
 
 def check_mesh(verts, tris) -> dict:

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/src/bytecode_compiler.cpp

@@ -567,6 +567,19 @@ public:
                         // evalBuiltinFunction when isImport is set.
                         site.isImport = true;
                         isStatic = true;
+                    } else if (const oscad::ASTNode* userFn =
+                                   scope_ ? scope_->lookupFunction(calleeName) : nullptr;
+                               userFn && userFn->kind() == NodeKind::FunctionDeclaration) {
+                        // A user-defined function SHADOWS a same-named
+                        // builtin, so this lookup runs BEFORE the builtin
+                        // table -- the same reordering as
+                        // evalFunctionCall's (user_calls.cpp), and it has
+                        // to happen here too: this decision is baked in at
+                        // COMPILE time, so leaving the builtin test first
+                        // would keep the bug on the default engine no
+                        // matter what the interpreter does.
+                        site.decl = static_cast<const oscad::FunctionDeclaration*>(userFn);
+                        isStatic = true;
                     } else if (isBuiltinFunctionName(calleeName)) {
                         // object() is already in this table -- it gets
                         // isBuiltin=true here like any other builtin, and
@@ -578,13 +591,10 @@ public:
                         // split positional/named CallArgs shape).
                         site.isBuiltin = true;
                         isStatic = true;
-                    } else {
-                        const oscad::ASTNode* found = scope_ ? scope_->lookupFunction(calleeName) : nullptr;
-                        if (found && found->kind() == NodeKind::FunctionDeclaration) {
-                            site.decl = static_cast<const oscad::FunctionDeclaration*>(found);
-                            isStatic = true;
-                        }
                     }
+                    // Anything else stays dynamic: a function-literal value,
+                    // or a name that is simply unknown. Op::CallDynamic
+                    // resolves it (and warns) at runtime.
                 }
 
                 if (!isStatic) {
@@ -626,7 +636,17 @@ public:
                 // is_undef(name) probes rather than reads -- the same quiet
                 // load the interpreter uses (Evaluator::undefProbeTarget),
                 // so the two engines agree on which reads warn.
-                if (const oscad::Identifier* undefProbe = Evaluator::undefProbeTarget(n)) {
+                //
+                // Only when the call resolves to the BUILTIN, though. A
+                // user function named is_undef shadows it (site resolution
+                // above) and evaluates its argument the ordinary way,
+                // warnings included -- which is what OpenSCAD does. The
+                // interpreter gets this for free by testing the probe
+                // inside its builtin branch; here the two are separate, so
+                // the condition has to be spelled out.
+                const oscad::Identifier* undefProbe =
+                    site.isBuiltin ? Evaluator::undefProbeTarget(n) : nullptr;
+                if (undefProbe) {
                     compileIdentifierLoad(undefProbe->name, undefProbe->position(), out, scope,
                                           /*warnIfUndef=*/false);
                     site.argNames.push_back(std::nullopt);

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/src/export.cpp

@@ -764,6 +764,91 @@ void writeX3d(const std::string& path, const std::vector<ExportObject>& objects)
     out << "  </Scene>\n</X3D>\n";
 }
 
+// AMF is XML like X3D, but its colour model is per-VOLUME rather than
+// per-face: a mesh carries one <vertices> list and any number of <volume>
+// blocks, each naming a material. So an object whose triangles are not all
+// one colour is written as one volume per distinct colour -- <color> on an
+// individual <triangle> is legal but far less widely read, and slicers are
+// the audience here.
+//
+// Material and object ids start at 1; id 0 is reserved by the spec.
+// The material table is global, so two objects sharing a colour share one
+// material entry rather than each declaring its own.
+void writeAmf(const std::string& path, const std::vector<ExportObject>& objects) {
+    std::ofstream out(path);
+    if (!out) throw std::runtime_error("Could not open '" + path + "' for writing");
+
+    std::vector<std::array<float, 4>> materials;
+    const auto materialFor = [&](const std::array<float, 4>& c) -> size_t {
+        for (size_t i = 0; i < materials.size(); ++i) {
+            if (materials[i] == c) return i + 1;
+        }
+        materials.push_back(c);
+        return materials.size();
+    };
+
+    struct Volume {
+        size_t material = 1;
+        std::vector<uint32_t> tris;
+    };
+    std::vector<std::vector<Volume>> perObject;
+    perObject.reserve(objects.size());
+    for (const ExportObject& o : objects) {
+        const FaceColors fc = faceColors(o);
+        std::vector<Volume> vols;
+        if (fc.palette.empty()) {
+            Volume v;
+            v.material = materialFor(o.color);
+            v.tris = o.tris;
+            vols.push_back(std::move(v));
+        } else {
+            vols.resize(fc.palette.size());
+            for (size_t i = 0; i < fc.palette.size(); ++i) vols[i].material = materialFor(fc.palette[i]);
+            for (size_t t = 0; t < o.tris.size() / 3; ++t) {
+                std::vector<uint32_t>& dst = vols[fc.index[t]].tris;
+                dst.push_back(o.tris[t * 3]);
+                dst.push_back(o.tris[t * 3 + 1]);
+                dst.push_back(o.tris[t * 3 + 2]);
+            }
+        }
+        perObject.push_back(std::move(vols));
+    }
+
+    out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    out << "<amf unit=\"millimeter\" version=\"1.1\">\n";
+    out << "  <metadata type=\"cad\">BelfrySCAD</metadata>\n";
+    for (size_t i = 0; i < materials.size(); ++i) {
+        const std::array<float, 4>& c = materials[i];
+        out << "  <material id=\"" << (i + 1) << "\">\n";
+        out << "    <color><r>" << formatG6(c[0]) << "</r><g>" << formatG6(c[1]) << "</g><b>"
+            << formatG6(c[2]) << "</b>";
+        if (c[3] < 1.0f) out << "<a>" << formatG6(c[3]) << "</a>";
+        out << "</color>\n";
+        out << "  </material>\n";
+    }
+    for (size_t oi = 0; oi < objects.size(); ++oi) {
+        const ExportObject& o = objects[oi];
+        out << "  <object id=\"" << (oi + 1) << "\">\n    <mesh>\n      <vertices>\n";
+        for (size_t v = 0; v < o.verts.size() / 3; ++v) {
+            out << "        <vertex><coordinates><x>" << formatG6(o.verts[v * 3]) << "</x><y>"
+                << formatG6(o.verts[v * 3 + 1]) << "</y><z>" << formatG6(o.verts[v * 3 + 2])
+                << "</z></coordinates></vertex>\n";
+        }
+        out << "      </vertices>\n";
+        for (const Volume& vol : perObject[oi]) {
+            if (vol.tris.empty()) continue;
+            out << "      <volume materialid=\"" << vol.material << "\">\n";
+            for (size_t t = 0; t < vol.tris.size() / 3; ++t) {
+                out << "        <triangle><v1>" << vol.tris[t * 3] << "</v1><v2>" << vol.tris[t * 3 + 1]
+                    << "</v2><v3>" << vol.tris[t * 3 + 2] << "</v3></triangle>\n";
+            }
+            out << "      </volume>\n";
+        }
+        out << "    </mesh>\n  </object>\n";
+    }
+    out << "</amf>\n";
+}
+
 
 // -- one entry point ------------------------------------------------------
 
@@ -779,7 +864,7 @@ std::string lowerExtension(const std::string& path) {
 }
 
 bool isMultiObject(const std::string& ext) {
-    return ext == ".3mf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
+    return ext == ".3mf" || ext == ".amf" || ext == ".obj" || ext == ".ply" || ext == ".wrl" || ext == ".x3d";
 }
 
 // The merged single mesh STL/OFF write, with the open shells kept.
@@ -898,7 +983,7 @@ void writeOffMesh(const std::string& path, const manifold::MeshGL& mesh) {
 } // namespace
 
 const std::vector<std::string>& exportExtensions() {
-    static const std::vector<std::string> exts = {".3mf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"};
+    static const std::vector<std::string> exts = {".3mf", ".amf", ".stl", ".obj", ".off", ".ply", ".wrl", ".x3d"};
     return exts;
 }
 
@@ -929,6 +1014,8 @@ std::vector<std::string> exportModel(const std::string& path, const std::vector<
         if (objects.empty()) throw std::runtime_error("No geometry to export");
         if (ext == ".3mf") {
             writeThreeMf(path, objects);
+        } else if (ext == ".amf") {
+            writeAmf(path, objects);
         } else if (ext == ".obj") {
             writeObj(path, objects);
         } else if (ext == ".ply") {

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/src/user_calls.cpp

@@ -876,11 +876,32 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
             CallArgs args = resolveArgs(*this, node.arguments, ctx);
             return importAsValue(*this, args, node);
         }
-        // A builtin function name always wins over a same-named user
-        // function -- checked *before* the user-function lookup, not
-        // after, matching the reference's _eval_function_call precedence
-        // exactly (name in _BUILTIN_FN_NAMES gates which branch runs at
-        // all).
+        // A user-defined function SHADOWS a same-named builtin, so the
+        // user lookup runs FIRST. Verified against OpenSCAD 2026.02.01:
+        // `function norm(x) = 999; echo(norm([3,4]));` echoes 999 there,
+        // and 5 here until this was fixed.
+        //
+        // The comment this replaces asserted the opposite order matched
+        // "the reference's _eval_function_call precedence exactly" -- but
+        // _eval_function_call / _BUILTIN_FN_NAMES are the old PYTHON
+        // evaluator, not OpenSCAD, and that prototype had it backwards.
+        // The C++ port inherited the mistake. Modules were always right
+        // (a user `module sphere()` does override the builtin); only
+        // functions resolved the wrong way round.
+        //
+        // bytecode_compiler.cpp's Op::CallFn site resolution has the same
+        // ordering and is fixed with it -- the VM is the default engine,
+        // so fixing only this one would leave the bug in place.
+        const oscad::ASTNode* decl = ctx.scope->lookupFunction(leftId->name);
+        if (decl && decl->kind() == oscad::NodeKind::FunctionDeclaration) {
+            // Call-site stop, in the CALLER's context, before descending
+            // into the callee (whose own body-entry stop comes later, from
+            // evalUserFunctionCore). Builtins deliberately get none --
+            // only the user-function and function-literal branches stop.
+            checkDebug(node, ctx, /*forced=*/false, /*exprLevel=*/false, /*callSite=*/true);
+            return evalUserFunction(leftId->name, static_cast<const oscad::FunctionDeclaration&>(*decl), node.arguments,
+                                     ctx, &node);
+        }
         if (isBuiltinFunctionName(leftId->name)) {
             // is_undef(name) is a probe: asking whether a name is defined
             // must not itself warn that it isn't. The $-branch of
@@ -901,17 +922,6 @@ Value Evaluator::evalFunctionCall(const oscad::PrimaryCall& node, EvalContext& c
             CallArgs args = resolveArgs(*this, node.arguments, ctx);
             return evalBuiltinFunction(*this, leftId->name, args, node);
         }
-        const oscad::ASTNode* decl = ctx.scope->lookupFunction(leftId->name);
-        if (decl && decl->kind() == oscad::NodeKind::FunctionDeclaration) {
-            // Call-site stop, in the CALLER's context, before descending
-            // into the callee (whose own body-entry stop comes later, from
-            // evalUserFunctionCore). Builtins deliberately get none --
-            // mirrors _eval_function_call, where only the user-function and
-            // function-literal branches call _check_debug.
-            checkDebug(node, ctx, /*forced=*/false, /*exprLevel=*/false, /*callSite=*/true);
-            return evalUserFunction(leftId->name, static_cast<const oscad::FunctionDeclaration&>(*decl), node.arguments,
-                                     ctx, &node);
-        }
     }
 
     // Not a builtin or user function -- check whether the callee expression

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/tests/test_export.cpp

@@ -121,3 +121,88 @@ TEST(ToRenderableBodies, A3dBodyPassesThroughUnchanged) {
     EXPECT_FALSE(renderable[0].flatPreview);
     EXPECT_NEAR(renderable[0].body->Volume(), 8.0, 1e-9);
 }
+
+// -- AMF -------------------------------------------------------------------
+
+namespace {
+
+std::string readFile(const std::string& path) {
+    std::ifstream in(path);
+    return std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());
+}
+
+size_t countOf(const std::string& hay, const std::string& needle) {
+    size_t n = 0, at = 0;
+    while ((at = hay.find(needle, at)) != std::string::npos) { ++n; at += needle.size(); }
+    return n;
+}
+
+} // namespace
+
+TEST(ExportAmf, IsAnOfferedFormat) {
+    const std::vector<std::string>& exts = exportExtensions();
+    EXPECT_NE(std::find(exts.begin(), exts.end(), ".amf"), exts.end());
+}
+
+TEST(ExportAmf, WritesOneObjectAndOneMaterialPerColour) {
+    // Two separated cubes, different colours: two objects, two materials.
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"blue\") cube(2);");
+    const std::string path = tempPath("two.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    // 12 triangles per cube, and every one lands in some volume.
+    EXPECT_EQ(countOf(xml, "<triangle>"), 24u);
+    EXPECT_NE(xml.find("<amf unit=\"millimeter\""), std::string::npos);
+    std::remove(path.c_str());
+}
+
+TEST(ExportAmf, TwoObjectsSharingAColourShareOneMaterial) {
+    std::vector<ColoredBody> bodies =
+        evalToBodies("color(\"red\") cube(2); translate([10,0,0]) color(\"red\") cube(2);");
+    const std::string path = tempPath("shared.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 1u);
+    std::remove(path.c_str());
+}
+
+TEST(ExportAmf, MaterialAndObjectIdsStartAtOne) {
+    // id 0 is reserved by the spec; a reader may drop anything using it.
+    std::vector<ColoredBody> bodies = evalToBodies("cube(2);");
+    const std::string path = tempPath("ids.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_NE(xml.find("<material id=\"1\">"), std::string::npos);
+    EXPECT_NE(xml.find("<object id=\"1\">"), std::string::npos);
+    EXPECT_EQ(xml.find("id=\"0\""), std::string::npos);
+    std::remove(path.c_str());
+}
+
+TEST(ExportAmf, NoGeometryThrows) {
+    std::vector<ColoredBody> empty;
+    EXPECT_THROW(exportModel(tempPath("empty.amf").string(), empty, ExportOptions{}), std::runtime_error);
+}
+
+TEST(ExportAmf, AMultiColouredObjectBecomesOneVolumePerColour) {
+    // A union welds these into ONE solid whose surface carries two colours.
+    // AMF has no per-face colour that slicers read reliably, so the object
+    // is written as one <volume> per colour -- which is exactly what a
+    // multimaterial slicer assigns to separate tools.
+    std::vector<ColoredBody> bodies = evalToBodies(
+        "union() { color(\"red\") cube(20); color(\"blue\") translate([10,5,5]) cube(20); }");
+    const std::string path = tempPath("multi.amf").string();
+    exportModel(path, bodies, ExportOptions{});
+
+    const std::string xml = readFile(path);
+    EXPECT_EQ(countOf(xml, "<object id="), 1u);
+    EXPECT_EQ(countOf(xml, "<volume materialid="), 2u);
+    EXPECT_EQ(countOf(xml, "<material id="), 2u);
+    std::remove(path.c_str());
+}

{openscad_cpp_evaluator-0.45.1 → openscad_cpp_evaluator-0.47.0}/tests/test_function_builtins.cpp

@@ -508,18 +508,99 @@ TEST(ObjectBuiltin, PositionalNonObjectNonListArgumentIsUndef) {
     EXPECT_TRUE(isUndef(evalSrc("object(5)", ev)));
 }
 
-// -- Precedence: a builtin function name always wins over a same-named --
-// user function, unlike modules (where a user module CAN shadow a builtin).
+// -- Precedence: a user function SHADOWS a same-named builtin ------------
+//
+// Same rule as modules, which always got this right. It used to be
+// backwards for functions: the builtin won, because the port copied the old
+// Python evaluator's _eval_function_call order rather than OpenSCAD's.
+//
+// Read off OpenSCAD 2026.02.01:
+//   function abs(x) = 999;  echo(abs(-3));            -> 999
+//   function is_undef(x) = "mine"; echo(is_undef(q)); -> "mine", and it
+//       WARNS about the unknown variable q, because a user function
+//       evaluates its arguments normally -- only the builtin probe is
+//       silent.
+//
+// Every case runs under both engines: the VM decides builtin-vs-user at
+// COMPILE time (bytecode_compiler.cpp), so it needs its own fix and its
+// own coverage.
 
-TEST(FunctionBuiltinPrecedence, BuiltinWinsOverSameNamedUserFunction) {
-    Evaluator ev;
-    auto ast = parseSrc("function abs(x) = 999;\nresult = abs(-3);");
-    auto scope = oscad::buildScopes(ast);
-    auto* assign = dynamic_cast<oscad::Assignment*>(ast[1].get());
-    ASSERT_NE(assign, nullptr);
-    EvalContext ctx = EvalContext::makeRoot(scope.get());
-    Value v = ev.evalExpr(*assign->expr, ctx);
-    EXPECT_DOUBLE_EQ(asNum(v), 3.0); // builtin abs(), not the user's abs()
+namespace {
+
+class ScopedVm {
+public:
+    explicit ScopedVm(bool enabled) { Evaluator::setBytecodeVmEnabledForTesting(enabled); }
+    ~ScopedVm() { Evaluator::setBytecodeVmEnabledForTesting(std::nullopt); }
+};
+
+std::vector<std::string> echoesOf(const std::string& src) {
+    std::vector<std::string> out;
+    oscadeval::test::evalSrc(src, [&](const std::string& m) { out.push_back(m); });
+    return out;
+}
+
+} // namespace
+
+TEST(FunctionBuiltinPrecedence, UserFunctionShadowsSameNamedBuiltin) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("function abs(x) = 999;\necho(abs(-3));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("999"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, TheBuiltinStillWinsWhenNobodyRedefinesIt) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("echo(abs(-3));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("3"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+        EXPECT_EQ(e[0].find("999"), std::string::npos) << "vm=" << vm;
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, ShadowingHoldsInsideAUserFunctionBody) {
+    // The call is inside another function, so on the VM path it is reached
+    // through a COMPILED chunk rather than the interpreter -- this is the
+    // case a compiler-side fix is needed for.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e =
+            echoesOf("function abs(x) = 999;\nfunction outer() = abs(-3);\necho(outer());");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm;
+        EXPECT_NE(e[0].find("999"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, AUserDefinedIsUndefShadowsTheProbe) {
+    // is_undef() is the one builtin with argument handling of its own (it
+    // must not warn about the name it is probing). A user's own is_undef
+    // takes over completely, arguments evaluated the ordinary way -- so the
+    // unknown-variable warning the probe suppresses DOES appear, exactly as
+    // upstream.
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        std::vector<std::string> msgs;
+        oscadeval::test::evalSrc("function is_undef(x) = \"mine\";\necho(is_undef(nothing));",
+                                  [&](const std::string& m) { msgs.push_back(m); });
+        bool sawMine = false, sawWarning = false;
+        for (const std::string& m : msgs) {
+            if (m.find("mine") != std::string::npos) sawMine = true;
+            if (m.find("nothing") != std::string::npos) sawWarning = true;
+        }
+        EXPECT_TRUE(sawMine) << "vm=" << vm;
+        EXPECT_TRUE(sawWarning) << "vm=" << vm << ": a user function evaluates its argument normally";
+    }
+}
+
+TEST(FunctionBuiltinPrecedence, TheIsUndefProbeIsStillSilentWhenNotRedefined) {
+    for (bool vm : {false, true}) {
+        ScopedVm guard(vm);
+        const std::vector<std::string> e = echoesOf("echo(is_undef(nothing));");
+        ASSERT_EQ(e.size(), 1u) << "vm=" << vm << ": probing must not warn";
+        EXPECT_NE(e[0].find("true"), std::string::npos) << "vm=" << vm << ", got " << e[0];
+    }
 }
 
 // -- Builtin argument diagnostics (reference parity) ---------------------