openscad-cpp-evaluator 1.37.1__tar.gz → 1.38.0__tar.gz

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/CLAUDE.md

@@ -507,6 +507,30 @@ Requires the same toolchain as `openscad_cpp_parser`: CMake ≥3.24, a C++20 com
 (macOS: `brew install bison`, the submodule's own CMakeLists auto-detects Homebrew's), Flex.
 GoogleTest is fetched automatically via `FetchContent`.
 
+### Building offline (Flathub)
+
+Every dependency is a `FetchContent` download pinned to a tag, commit or checksummed tarball --
+**keep it that way**: an unpinned `master` makes two builds of one tag differ and rules out a
+build that lists its sources by checksum. A build with no network (Flathub's) hands each one in as
+a source directory and forbids downloading:
+
+```bash
+cmake -S . -B build -DFETCHCONTENT_FULLY_DISCONNECTED=ON -DBUILD_TESTING=OFF \
+  -DFETCHCONTENT_SOURCE_DIR_MANIFOLD=...      -DFETCHCONTENT_SOURCE_DIR_CLIPPER2=... \
+  -DFETCHCONTENT_SOURCE_DIR_BOOST_CONFIG=...  -DFETCHCONTENT_SOURCE_DIR_BOOST_POLYGON=... \
+  -DFETCHCONTENT_SOURCE_DIR_FREETYPE=...      -DFETCHCONTENT_SOURCE_DIR_HARFBUZZ=... \
+  -DFETCHCONTENT_SOURCE_DIR_STB=...           -DFETCHCONTENT_SOURCE_DIR_CPP_LINENOISE=... \
+  -DFETCHCONTENT_SOURCE_DIR_NLOHMANN_JSON=...
+```
+
+That is the whole list for a wheel build (tests off; GoogleTest is the only other download, and
+TBB only with `MANIFOLD_PAR`). Clipper2 is Manifold's own download, pinned in Manifold's
+`cmake/manifoldDeps.cmake`; nlohmann_json is the parser's. FetchContent skips `PATCH_COMMAND` for a
+supplied source, so the root `CMakeLists.txt` runs `cmake/patch_manifold.cmake` itself when
+`FETCHCONTENT_SOURCE_DIR_MANIFOLD` is set -- otherwise an offline build would quietly ship the heap
+overflow that patch fixes. Verified 2026-10-06: a fully disconnected configure + build produced the
+Python module and CLI, and rendered text (freetype + harfbuzz).
+
 Run a single test binary or filter:
 
 ```bash
@@ -1842,3 +1866,33 @@ A compiled function keeps its parameters in frame slots, which no `EvalContext`
 can see, and the children are statement opcodes that resolve names through the
 context — without this, `function f(w) = render() { cube(w); }.volume;` finds no
 `w` and silently measures nothing.
+
+## `profile_time()`
+
+`profile_time([label]) { ... }` prints `PROFILE: label: T ms (script S ms, geometry G ms)`;
+`x = profile_time([label]) expr;` prints `PROFILE: label: T ms` and evaluates to `expr`'s value.
+`supported_feature("profile-time")` is 1. The label is optional (default `line N of file`), and
+is evaluated before the clock starts. Times under 1 ms print in microseconds (`fmtMs`), so a fast part never reads `0.00 ms`.
+
+### Implementation notes
+
+- **Parser:** `profile_time` is a reserved keyword (`KW_PROFILE_TIME`) for the same reason as
+  `render`. The statement form is a plain `ModularCall` named `profile_time`; the expression form
+  is a `ProfileTimeOp` node shaped like `EchoOp`, with a required body.
+- **Script time** is taken around the resolve function's call in `Evaluator::evalModularCall`
+  (csg_resolve.cpp), not inside `resolveProfileTime`, so argument evaluation and every child
+  count. It is stored on `CSGNode::profileScriptMs`, which is deliberately not in `cacheKey()` --
+  a timing in the key would make every profiled subtree a permanent miss.
+- **Geometry time** is taken in `generateTreeImpl`, from *before* the cache lookup, and printed
+  when the node finishes, so a hit reports `geometry cached` rather than vanishing. A hit on an
+  **ancestor** never visits the profile_time() node at all; `reportCachedProfiles` walks the hit
+  subtree for them, but only when the run resolved any (`profileNodeCount_`), so a model without
+  profile_time() pays nothing on its hits.
+- **Resolve-only runs** (`evaluate(..., generate=false)`) print `script S ms (no geometry built)`
+  at resolve time instead (`generateRequested_`).
+- **Expression form** is interpreter-only: the bytecode compiler has no case for
+  `ProfileTimeOp`, so its `default:` throws `NotCompilable` and the containing function falls back
+  to the interpreter. It is also deliberately absent from `simplifyTailStep` -- the clock must stop
+  after the body, which a tail step would not wait for.
+- `PROFILE:` lines go straight to `echoFn_`, not through `emitWarning`, so the ManifoldCache never
+  stores or replays them (a replay would print a stale time as if it were current).

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/CMakeLists.txt

@@ -141,6 +141,16 @@ FetchContent_Declare(
   # CsgLeafNode::Compose -- see cmake/patch_manifold.cmake.
   PATCH_COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/patch_manifold.cmake
 )
+# FetchContent runs PATCH_COMMAND only for a source it downloads itself, so
+# a build handed Manifold's source (FETCHCONTENT_SOURCE_DIR_MANIFOLD, as an
+# offline Flatpak build does) would otherwise compile it unpatched. The
+# script is idempotent, so running it here too is safe.
+if(FETCHCONTENT_SOURCE_DIR_MANIFOLD)
+  execute_process(
+    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/cmake/patch_manifold.cmake
+    WORKING_DIRECTORY ${FETCHCONTENT_SOURCE_DIR_MANIFOLD}
+    COMMAND_ERROR_IS_FATAL ANY)
+endif()
 FetchContent_MakeAvailable(manifold)
 
 # Boost.Polygon's Voronoi diagram builder, for roof()'s general (multi-
@@ -158,7 +168,13 @@ FetchContent_MakeAvailable(boost_config boost_polygon)
 # path, not add_subdirectory/MakeAvailable's target machinery. (It used to
 # supply stb_truetype.h for the font backend too; FreeType/HarfBuzz below
 # replaced that.)
-FetchContent_Declare(stb GIT_REPOSITORY https://github.com/nothings/stb.git GIT_TAG master GIT_SHALLOW TRUE)
+#
+# Pinned to a commit, as everything here is: stb has no releases, and
+# following master made two builds of the same tag differ, which also rules
+# out an offline (Flathub) build listing its sources by checksum.
+FetchContent_Declare(stb
+  URL https://github.com/nothings/stb/archive/2c980bb59875b0d32144a71867fbdebb2f77cd20.tar.gz
+  URL_HASH SHA256=9a955b1b49a4410088a2e0ee2a9c057c3c907d0c1d75454144cb980aca0ba515)
 FetchContent_MakeAvailable(stb)
 
 # FreeType (glyph outlines + face metrics) and HarfBuzz (shaping), the two
@@ -221,7 +237,10 @@ FetchContent_MakeAvailable(harfbuzz)
 # `CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR`, so FetchContent_
 # MakeAvailable here only exposes its `linenoise` INTERFACE target, matching
 # the existing MANIFOLD_TEST-override pattern's intent for free.
-FetchContent_Declare(cpp_linenoise GIT_REPOSITORY https://github.com/yhirose/cpp-linenoise.git GIT_TAG master GIT_SHALLOW TRUE)
+# Pinned to a commit for the same reason as stb: no releases.
+FetchContent_Declare(cpp_linenoise
+  URL https://github.com/yhirose/cpp-linenoise/archive/b0e8b88f53be0de26252180b1b959c6dd67ec4a9.tar.gz
+  URL_HASH SHA256=e3e67ea401a9e6e19c300f025c51faab197b83254c83e6bef8ef452ee184548b)
 FetchContent_MakeAvailable(cpp_linenoise)
 
 # Embeds the bundled default font's (resources/fonts/) raw bytes into a

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/ast/ast_node.hpp

@@ -34,6 +34,7 @@ enum class NodeKind {
     LetOp,
     EchoOp,
     AssertOp,
+    ProfileTimeOp,
     FunctionLiteral,
     // Operators
     UnaryMinusOp,

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/include/openscad_cpp_parser/ast/expression.hpp

@@ -217,6 +217,20 @@ public:
     void buildScope(Scope& parentScope) override;
 };
 
+// `profile_time(arguments...) body` -- same shape as EchoOp; times the body.
+// Unlike echo/assert the body is required: timing nothing is meaningless.
+class ProfileTimeOp : public Expression {
+public:
+    ProfileTimeOp(Position position, std::vector<std::unique_ptr<Argument>> arguments, std::unique_ptr<Expression> body)
+        : Expression(NodeKind::ProfileTimeOp, std::move(position)), arguments(std::move(arguments)), body(std::move(body)) {}
+
+    std::vector<std::unique_ptr<Argument>> arguments;
+    std::unique_ptr<Expression> body;
+
+    std::string toString() const override;
+    void buildScope(Scope& parentScope) override;
+};
+
 // `assert(arguments...) body` -- same shape as EchoOp.
 class AssertOp : public Expression {
 public:

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/ast/ast_node.cpp

@@ -21,6 +21,7 @@ const char* nodeKindName(NodeKind kind) {
         case NodeKind::LetOp: return "LetOp";
         case NodeKind::EchoOp: return "EchoOp";
         case NodeKind::AssertOp: return "AssertOp";
+        case NodeKind::ProfileTimeOp: return "ProfileTimeOp";
         case NodeKind::FunctionLiteral: return "FunctionLiteral";
         case NodeKind::UnaryMinusOp: return "UnaryMinusOp";
         case NodeKind::AdditionOp: return "AdditionOp";

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/ast/expression.cpp

@@ -134,6 +134,18 @@ void EchoOp::buildScope(Scope& parentScope) {
     body->buildScope(parentScope);
 }
 
+std::string ProfileTimeOp::toString() const {
+    return "profile_time(" + joinToString(arguments, ", ") + ") " + body->toString();
+}
+
+void ProfileTimeOp::buildScope(Scope& parentScope) {
+    setScope(parentScope);
+    for (auto& a : arguments) {
+        a->buildScope(parentScope);
+    }
+    body->buildScope(parentScope);
+}
+
 std::string AssertOp::toString() const {
     return "assert(" + joinToString(arguments, ", ") + ") " + body->toString();
 }
@@ -219,6 +231,7 @@ int operatorPrecedence(NodeKind kind) {
         case NodeKind::LetOp:
         case NodeKind::EchoOp:
         case NodeKind::AssertOp:
+        case NodeKind::ProfileTimeOp:
         case NodeKind::FunctionLiteral:
             return 0;
         case NodeKind::LogicalOrOp:

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/grammar/driver.cpp

@@ -88,6 +88,11 @@ NodePtr makeEchoOp(ParserDriver& driver, const OscadLocation& loc, NodeList argu
                                      nodeCast<Expression>(std::move(body)));
 }
 
+NodePtr makeProfileTimeOp(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodePtr body) {
+    return std::make_unique<ProfileTimeOp>(driver.toPosition(loc), nodeListCast<Argument>(std::move(arguments)),
+                                            nodeCast<Expression>(std::move(body)));
+}
+
 NodePtr makeAssertOp(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodePtr body) {
     return std::make_unique<AssertOp>(driver.toPosition(loc), nodeListCast<Argument>(std::move(arguments)),
                                        nodeCast<Expression>(std::move(body)));

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/grammar/driver.hpp

@@ -104,6 +104,7 @@ NodePtr makeAssignment(ParserDriver& driver, const OscadLocation& loc, const Osc
 
 NodePtr makeLetOp(ParserDriver& driver, const OscadLocation& loc, NodeList assignments, NodePtr body);
 NodePtr makeEchoOp(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodePtr body);
+NodePtr makeProfileTimeOp(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodePtr body);
 NodePtr makeAssertOp(ParserDriver& driver, const OscadLocation& loc, NodeList arguments, NodePtr body);
 NodePtr makeFunctionLiteral(ParserDriver& driver, const OscadLocation& loc, NodeList parameters, NodePtr body);
 

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/grammar/lexer.l

@@ -52,6 +52,9 @@ const std::unordered_map<std::string, KeywordFactory>& keywordTable() {
         // apart from a function call. Note `$render` still lexes as NAME --
         // this table is keyed on the full IDENT text, including the `$`.
         {"render", [](const OscadLocation& l) { return yy::parser::make_KW_RENDER(l); }},
+        // Reserved for the same reason as `render`: its expression form
+        // (`x = profile_time("label") expr;`) starts like a function call.
+        {"profile_time", [](const OscadLocation& l) { return yy::parser::make_KW_PROFILE_TIME(l); }},
         {"undef", [](const OscadLocation& l) { return yy::parser::make_KW_UNDEF(l); }},
         {"true", [](const OscadLocation& l) { return yy::parser::make_KW_TRUE(l); }},
         {"false", [](const OscadLocation& l) { return yy::parser::make_KW_FALSE(l); }},

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/grammar/parser.y

@@ -93,6 +93,7 @@
   KW_INTERSECTION_FOR "intersection_for"
   KW_EACH "each"
   KW_RENDER "render"
+  KW_PROFILE_TIME "profile_time"
   KW_UNDEF "undef"
   KW_TRUE "true"
   KW_FALSE "false"
@@ -158,7 +159,7 @@
 %type <NodePtr> modifier_show_only modifier_highlight modifier_background modifier_disable
 %type <NodePtr> if_statement ifelse_statement
 %type <NodePtr> modular_for modular_intersection_for modular_let modular_assert modular_echo modular_call
-%type <NodePtr> render_stmt render_expr
+%type <NodePtr> render_stmt render_expr profile_time_stmt
 %type <NodePtr> expr opchain postfix primary
 %type <NodePtr> range_expr vector_expr vector_element
 %type <NodePtr> listcomp_elements listcomp_paren_expr listcomp_let listcomp_each
@@ -330,6 +331,7 @@ single_module_instantiation:
   | modular_echo                  { $$ = std::move($1); }
   | modular_call                   { $$ = std::move($1); }
   | render_stmt                     { $$ = std::move($1); }
+  | profile_time_stmt                { $$ = std::move($1); }
   ;
 
 modular_for:
@@ -378,6 +380,14 @@ render_stmt:
     }
   ;
 
+// Same arrangement as render_stmt: the keyword exists only for the
+// expression form, and the statement form is an ordinary builtin call.
+profile_time_stmt:
+    "profile_time" "(" arguments ")" child_statement {
+      $$ = makeModularCall(driver, @$, @1, "profile_time", std::move($3), std::move($5));
+    }
+  ;
+
 // -- Expressions ----------------------------------------------------------
 //
 // `expr` covers let/assert/echo/funclit_def/ternary plus the operator
@@ -393,6 +403,7 @@ expr:
   | "assert" "(" arguments ")"            { $$ = makeAssertOp(driver, @$, std::move($3), makeUndefinedLiteral(driver, @$)); }
   | "echo" "(" arguments ")" expr          { $$ = makeEchoOp(driver, @$, std::move($3), std::move($5)); }
   | "echo" "(" arguments ")"                { $$ = makeEchoOp(driver, @$, std::move($3), makeUndefinedLiteral(driver, @$)); }
+  | "profile_time" "(" arguments ")" expr    { $$ = makeProfileTimeOp(driver, @$, std::move($3), std::move($5)); }
   | "function" "(" parameters ")" expr        { $$ = makeFunctionLiteral(driver, @$, std::move($3), std::move($5)); }
   | opchain "?" expr ":" expr                  { $$ = makeTernaryOp(driver, @$, std::move($1), std::move($3), std::move($5)); }
   | opchain                                     { $$ = std::move($1); }

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/inline_comment_attach.cpp

@@ -180,6 +180,12 @@ void classifyNode(ASTNode& node, std::vector<ExprSlot>& exprFields, std::vector<
             addExpr(n.body, exprFields);
             break;
         }
+        case NodeKind::ProfileTimeOp: {
+            auto& n = static_cast<ProfileTimeOp&>(node);
+            addArgumentExprList(n.arguments, exprFields);
+            addExpr(n.body, exprFields);
+            break;
+        }
         case NodeKind::AssertOp: {
             auto& n = static_cast<AssertOp&>(node);
             addArgumentExprList(n.arguments, exprFields);

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/pretty_print.cpp

@@ -486,6 +486,9 @@ std::string fmtExpr(const ASTNode& exprNode, int indent, int w) {
         }
         return "echo(" + args + ")\n" + pad + fmtExpr(*e->body, indent, w);
     }
+    if (auto* p = dynamic_cast<const ProfileTimeOp*>(&exprNode)) {
+        return "profile_time(" + joinToString(p->arguments, ", ") + ")\n" + pad + fmtExpr(*p->body, indent, w);
+    }
     if (auto* l = dynamic_cast<const LetOp*>(&exprNode)) {
         return fmtLetOpExpr(*l, indent, w);
     }

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/src/serialization/json_io.cpp

@@ -150,6 +150,12 @@ json toJsonImpl(const ASTNode& node, bool includePos) {
             j["body"] = valueToJson(n.body.get(), includePos);
             break;
         }
+        case NodeKind::ProfileTimeOp: {
+            auto& n = static_cast<const ProfileTimeOp&>(node);
+            j["arguments"] = listToJson(n.arguments, includePos);
+            j["body"] = valueToJson(n.body.get(), includePos);
+            break;
+        }
         case NodeKind::AssertOp: {
             auto& n = static_cast<const AssertOp&>(node);
             j["arguments"] = listToJson(n.arguments, includePos);
@@ -446,6 +452,11 @@ const std::unordered_map<std::string, Builder>& registry() {
              return std::make_unique<EchoOp>(std::move(pos), listFromJson<Argument>(j, "arguments"),
                                               childFromJson<Expression>(j, "body"));
          }},
+        {"ProfileTimeOp",
+         [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {
+             return std::make_unique<ProfileTimeOp>(std::move(pos), listFromJson<Argument>(j, "arguments"),
+                                                     childFromJson<Expression>(j, "body"));
+         }},
         {"AssertOp",
          [](const json& j, Position pos) -> std::unique_ptr<ASTNode> {
              return std::make_unique<AssertOp>(std::move(pos), listFromJson<Argument>(j, "arguments"),

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/external/openscad_cpp_parser/tests/CMakeLists.txt

@@ -26,6 +26,7 @@ add_executable(oscad_tests
   test_ast_generation.cpp
   test_node_str.cpp
   test_render_expression.cpp
+  test_profile_time.cpp
   test_strict_commas.cpp
   test_concurrent_parse.cpp
 )

openscad_cpp_evaluator-1.38.0/external/openscad_cpp_parser/tests/test_profile_time.cpp

@@ -0,0 +1,86 @@
+// `profile_time()`: the statement form times its children, the expression
+// form (`x = profile_time("label") expr;`) its body. `profile_time` is a
+// reserved keyword only because the expression form would otherwise be
+// indistinguishable from a function call; the statement form is a plain
+// ModularCall, so builtin dispatch downstream sees an ordinary module.
+
+#include "openscad_cpp_parser/api.hpp"
+#include "openscad_cpp_parser/pretty_print.hpp"
+#include "openscad_cpp_parser/serialization.hpp"
+#include "test_helpers.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace oscad;
+
+namespace {
+
+const ProfileTimeOp* profileOf(const std::vector<std::unique_ptr<ASTNode>>& ast) {
+    auto* a = dynamic_cast<Assignment*>(ast[0].get());
+    return a ? dynamic_cast<const ProfileTimeOp*>(a->expr.get()) : nullptr;
+}
+
+} // namespace
+
+TEST(ProfileTime, StatementFormIsAPlainModularCall) {
+    auto ast = parseSrc("profile_time(\"gears\") { cube(1); sphere(2); }");
+    ASSERT_EQ(ast.size(), 1u);
+    auto* call = dynamic_cast<ModularCall*>(ast[0].get());
+    ASSERT_NE(call, nullptr);
+    EXPECT_EQ(call->name->name, "profile_time");
+    EXPECT_EQ(call->arguments.size(), 1u);
+    EXPECT_EQ(call->children.size(), 2u);
+}
+
+TEST(ProfileTime, ExpressionFormWrapsItsBody) {
+    auto ast = parseSrc("x = profile_time(\"sum\") 1 + 2;");
+    const ProfileTimeOp* p = profileOf(ast);
+    ASSERT_NE(p, nullptr);
+    EXPECT_EQ(p->kind(), NodeKind::ProfileTimeOp);
+    EXPECT_EQ(p->arguments.size(), 1u);
+    EXPECT_EQ(p->body->kind(), NodeKind::AdditionOp);
+}
+
+TEST(ProfileTime, ExpressionFormAllowsNoLabel) {
+    const ProfileTimeOp* p = nullptr;
+    auto ast = parseSrc("x = profile_time() f(3);");
+    p = profileOf(ast);
+    ASSERT_NE(p, nullptr);
+    EXPECT_TRUE(p->arguments.empty());
+}
+
+TEST(ProfileTime, ExpressionFormNeedsABody) {
+    EXPECT_THROW(parseSrc("x = profile_time(\"a\");"), ParseError);
+}
+
+TEST(ProfileTime, IsReserved) {
+    EXPECT_THROW(parseSrc("profile_time = 1;"), ParseError);
+    EXPECT_THROW(parseSrc("function profile_time() = 1;"), ParseError);
+    EXPECT_THROW(parseSrc("module profile_time() {}"), ParseError);
+    // `$profile_time` is a different identifier and stays usable.
+    EXPECT_NO_THROW(parseSrc("$profile_time = 1;"));
+}
+
+TEST(ProfileTime, ToStringRoundTrips) {
+    auto ast = parseSrc("x = profile_time(\"a\") 1 + 2;");
+    EXPECT_EQ(ast[0]->toString(), "x = profile_time(\"a\") 1 + 2");
+    EXPECT_NE(profileOf(parseSrc(ast[0]->toString() + ";")), nullptr);
+}
+
+TEST(ProfileTime, JsonRoundTrips) {
+    auto ast = parseSrc("x = profile_time(\"a\") 1 + 2;");
+    auto back = astFromJsonString(astToJsonString(ast));
+    const ProfileTimeOp* p = profileOf(back);
+    ASSERT_NE(p, nullptr);
+    EXPECT_EQ(p->body->kind(), NodeKind::AdditionOp);
+}
+
+TEST(ProfileTime, PrettyPrintReparses) {
+    for (const char* src : {"x = profile_time(\"a\") 1 + 2;",
+                            "profile_time(\"g\") { cube(1); }"}) {
+        auto ast = parseSrc(src);
+        std::string out = toOpenscad(ast);
+        EXPECT_NE(out.find("profile_time(\""), std::string::npos) << out;
+        EXPECT_NO_THROW(parseSrc(out)) << out;
+    }
+}

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/include/openscad_cpp_evaluator/csg_node.hpp

@@ -71,6 +71,13 @@ struct CSGNode {
     // stack risk the moment this node is ever destroyed.
     int treeDepth = 1;
 
+    // profile_time() only: how long resolving this node (its arguments and
+    // its children's script code) took, in ms; < 0 for every other node.
+    // Measured fresh on every run, so -- like warnEntry -- deliberately NOT
+    // part of cacheKey(): putting a timing in the key would make every
+    // profiled subtree a permanent cache miss.
+    double profileScriptMs = -1.0;
+
     // Memoizes manifold_cache.cpp's cacheKey(*this) -- that function
     // recurses into every descendant to build its own key, so without this
     // memo a generate-time walk that calls cacheKey() at every node (not

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -422,6 +422,22 @@ public:
     // subtree, not just direct children, since hull() consumes all of it.
     bool insideHull = false;
 
+    // profile_time(). generateRequested_ is false only inside an
+    // evaluate(generate = false) run, where no geometry pass follows to
+    // report a profiled block, so resolve reports the script time alone.
+    // profileNodeCount_ counts this run's profile_time() nodes so a cache
+    // hit only walks its subtree for them when there are any (see
+    // reportCachedProfiles).
+    bool generateRequested_ = true;
+    std::size_t profileNodeCount_ = 0;
+    // Prints "PROFILE: <label>: ..." for a profile_time() node. geometryMs
+    // < 0 means no geometry pass; `cached` means its geometry came from the
+    // ManifoldCache rather than being built.
+    void reportProfile(const CSGNode& node, double geometryMs, bool cached);
+    // A cache hit at `node` skips its whole subtree, so a profile_time()
+    // inside it would otherwise print nothing at all.
+    void reportCachedProfiles(const CSGNode& node);
+
     ColoredBody tagGenerated(manifold::Manifold body, const oscad::ASTNode& node, const Value& colorValue);
 
     // tagGenerated()'s counterpart for a mesh Manifold refused to build --
@@ -837,6 +853,7 @@ private:
     Value evalLetExpr(const oscad::LetOp& node, EvalContext& ctx);
     Value evalEchoExpr(const oscad::EchoOp& node, EvalContext& ctx);
     Value evalAssertExpr(const oscad::AssertOp& node, EvalContext& ctx);
+    Value evalProfileTimeExpr(const oscad::ProfileTimeOp& node, EvalContext& ctx);
     void bindLetName(EvalContext& ctx, const std::string& name, const Value& v);
 
     // Bracketed public in place: Stage 2's Op::NativeStatement

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/CMakeLists.txt

@@ -43,6 +43,7 @@ add_library(openscad_cpp_evaluator STATIC
   builtins/booleans.cpp
   builtins/modifiers.cpp
   builtins/control.cpp
+  builtins/profile_time.cpp
   builtins/function_builtins.cpp
   builtins/import.cpp
   builtins/topology.cpp

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/builtins/builtins.hpp

@@ -146,6 +146,12 @@ std::vector<ColoredBody> generateChildren(Evaluator& ev, const CSGParams& params
 // generateTree()'s default child-concatenation, exactly reproducing
 // passthrough).
 CSGParams resolveRender(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+CSGParams resolveProfileTime(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx);
+// profile_time()'s message pieces: "12.40 ms" (or "4.7 µs" under 1 ms), and the label it names --
+// the label as written (a non-string formatted like echo() would), or
+// "line N" (with the file when there is one) when none was given.
+std::string fmtMs(double ms);
+std::string profileLabel(const Value& label, const oscad::Position& pos);
 
 // breakpoint() -- no-op as of Phase 4 (no debugger until Phase 9); still
 // evaluates/validates its optional `condition` argument for parity.

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/builtins/function_builtins.cpp

@@ -1018,6 +1018,7 @@ const std::unordered_map<std::string, double>& featureLevels() {
         {"roof-op", 1.0},            // roof(), method="voronoi" only
         {"svg-class", 1.0},          // import(svg, class=); id= is upstream's
         {"discretization-by-error", 1.0}, // $fe, always on (upstream: behind --enable)
+        {"profile-time", 1.0},       // profile_time(label) { ... } and profile_time(label) expr
     };
     return levels;
 }

openscad_cpp_evaluator-1.38.0/src/builtins/profile_time.cpp

@@ -0,0 +1,63 @@
+#include "builtins.hpp"
+
+#include "openscad_cpp_evaluator/call_args.hpp"
+#include "openscad_cpp_evaluator/evaluator.hpp"
+
+#include <cstdio>
+
+namespace oscadeval {
+
+// Microseconds below a millisecond, where "0.00 ms" would hide the answer.
+std::string fmtMs(double ms) {
+    char buf[32];
+    if (ms < 1.0) std::snprintf(buf, sizeof buf, "%.1f \u00b5s", ms * 1000.0);
+    else std::snprintf(buf, sizeof buf, "%.2f ms", ms);
+    return buf;
+}
+
+std::string profileLabel(const Value& label, const oscad::Position& pos) {
+    if (const std::string* s = std::get_if<std::string>(&label)) return *s;
+    if (!std::holds_alternative<std::monostate>(label)) return fmtValue(label);
+    std::string where = "line " + std::to_string(pos.line);
+    if (!pos.origin.empty()) where += " of " + pos.origin.substr(pos.origin.find_last_of("/\\") + 1);
+    return where;
+}
+
+// profile_time([label]) { ... } -- resolves its children like render() does.
+// The script-time clock is NOT here but around this call in
+// Evaluator::evalModularCall, so it covers argument evaluation and every
+// child alike; the geometry time is taken in generateTreeImpl. The label
+// goes into params (it is constant, so it costs the cache nothing).
+CSGParams resolveProfileTime(Evaluator& ev, const oscad::ModularCall& node, EvalContext& ctx) {
+    auto [args, effCtx] = resolveCallArgs(ev, node.arguments, ctx);
+    CSGParams params;
+    params["label"] = getArg(args, 0, "label");
+    EvalContext blockCtx = ev.blockScope(effCtx);
+    ev.evalChildren(node.children, blockCtx);
+    return params;
+}
+
+void Evaluator::reportProfile(const CSGNode& node, double geometryMs, bool cached) {
+    if (!echoFn_ || node.node == nullptr) return;
+    auto it = node.params.find("label");
+    const std::string label = profileLabel(it == node.params.end() ? Value{} : it->second, node.node->position());
+    const double scriptMs = node.profileScriptMs < 0 ? 0.0 : node.profileScriptMs;
+    std::string msg = "PROFILE: " + label + ": ";
+    if (geometryMs < 0) {
+        msg += "script " + fmtMs(scriptMs) + " (no geometry built)";
+    } else if (cached) {
+        msg += fmtMs(scriptMs) + " (script " + fmtMs(scriptMs) + ", geometry cached)";
+    } else {
+        msg += fmtMs(scriptMs + geometryMs) + " (script " + fmtMs(scriptMs) + ", geometry " + fmtMs(geometryMs) + ")";
+    }
+    echoFn_(msg);
+}
+
+void Evaluator::reportCachedProfiles(const CSGNode& node) {
+    for (const std::unique_ptr<CSGNode>& c : node.children) {
+        if (c->isBuiltin && c->kind == "profile_time") reportProfile(*c, 0.0, true);
+        reportCachedProfiles(*c);
+    }
+}
+
+} // namespace oscadeval

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/builtins/registry.cpp

@@ -26,6 +26,7 @@ const std::unordered_map<std::string_view, ResolveFn>& resolveDispatch() {
         {"intersection", &resolveCsg},
         {"children", &resolveChildren},
         {"render", &resolveRender},
+        {"profile_time", &resolveProfileTime},
         {"breakpoint", &resolveBreakpoint},
         {"import", &resolveImport},
         {"hull", &resolveHull},
@@ -118,6 +119,7 @@ const std::vector<std::string>* builtinParamNames(const std::string& name) {
         {"minkowski", {"convexity"}},
         {"children", {"index", "separate"}},
         {"render", {"convexity"}},
+        {"profile_time", {"label"}},
         // "repair" and "class" are this port's own additions, not upstream
         // parameters. ("id" IS upstream's, and was declared here long before
         // anything read it -- so a script filtering by id was accepted in

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/coverage.cpp

@@ -263,6 +263,12 @@ private:
                 expr(*o.body);
                 break;
             }
+            case NodeKind::ProfileTimeOp: {
+                auto& o = static_cast<const oscad::ProfileTimeOp&>(e);
+                args(o.arguments);
+                expr(*o.body);
+                break;
+            }
             case NodeKind::FunctionLiteral: {
                 auto& f = static_cast<const oscad::FunctionLiteral&>(e);
                 emit(&e, CoverageKind::Body);

{openscad_cpp_evaluator-1.37.1 → openscad_cpp_evaluator-1.38.0}/src/csg_generate.cpp

@@ -36,6 +36,10 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
     for (CSGNode* nodePtr : tree) {
         CSGNode& node = *nodePtr;
         checkCancel();
+        // profile_time(): timed from before the cache lookup, so a hit
+        // still reports (as cached) rather than vanishing.
+        const bool profiled = node.isBuiltin && node.kind == "profile_time";
+        const auto profileStart = profiled ? std::chrono::steady_clock::now() : std::chrono::steady_clock::time_point{};
 
         // ManifoldCache lookup: node.uncacheable (rands() taint, set
         // during resolve -- see csg_resolve.cpp) always forces a miss,
@@ -69,6 +73,8 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // one (BelfrySCAD #521). Goes through emitWarning so an enclosing
             // capture records them too, exactly as a fresh generate would.
             for (const std::string& w : cached->warnings) emitWarning(w);
+            // A hit skips the subtree, profile_time() calls and all.
+            if (profileNodeCount_ > 0) reportCachedProfiles(node);
             // Skipped entirely while measuring: restampCachedIds writes
             // idToNode/idToColor, and geometry that is about to be discarded
             // has no click-to-source identity worth recording. See
@@ -171,6 +177,11 @@ std::vector<ColoredBody> Evaluator::generateTreeImpl(const std::vector<CSGNode*>
             // capacity, and 35K nodes' worth of 592-byte slots was 230MB.
             for (const std::unique_ptr<CSGNode>& c : node.children) c->bodies = std::vector<ColoredBody>();
         }
+        if (profiled) {
+            reportProfile(node,
+                          std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - profileStart).count(),
+                          cached.has_value());
+        }
         for (const ColoredBody& b : node.bodies) topLevelBodies.push_back(b);
     }
     return topLevelBodies;