diff --git a/.gitignore b/.gitignore
index 67618ca90..215d72492 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,10 @@ thumbs.db
 
 .classpath
 android-runtime.iml
+
+# Emitted by tools/js2c.mjs from test-app/runtime/src/main/cpp/js during the build.
+test-app/runtime/src/main/cpp/generated/
+
 test-app/build-tools/*.log
 test-app/analytics/build-statistics.json
 package-lock.json
diff --git a/eslint.config.mjs b/eslint.config.mjs
new file mode 100644
index 000000000..96e48806f
--- /dev/null
+++ b/eslint.config.mjs
@@ -0,0 +1,38 @@
+// Lint setup for the runtime's builtin JavaScript
+// (test-app/runtime/src/main/cpp/js). Each file is compiled by BuiltinLoader
+// as a FUNCTION BODY with the fixed parameters `exports`, `module` and
+// `binding` (see that directory's README.md), which are declared as globals
+// here. no-undef is the typo net for binding-bag destructures and
+// native-global usage alike.
+import globals from 'globals';
+
+export default [
+  {
+    files: ['test-app/runtime/src/main/cpp/js/**/*.js'],
+    languageOptions: {
+      ecmaVersion: 2022,
+      sourceType: 'script',
+      globals: {
+        ...globals.es2021,
+        exports: 'readonly',
+        module: 'readonly',
+        binding: 'readonly',
+        global: 'readonly',
+        console: 'readonly',
+        URL: 'readonly',
+        URLSearchParams: 'readonly',
+        Blob: 'readonly',
+        File: 'readonly',
+        WebAssembly: 'readonly',
+        // Java package roots resolved through the metadata interceptor at
+        // runtime:
+        java: 'readonly',
+        org: 'readonly',
+      },
+    },
+    rules: {
+      'no-undef': 'error',
+      'no-unused-vars': ['error', { args: 'none', caughtErrors: 'none' }],
+    },
+  },
+];
diff --git a/package.json b/package.json
index 3e1ae3033..1c0a019f9 100644
--- a/package.json
+++ b/package.json
@@ -27,11 +27,14 @@
   },
   "scripts": {
     "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "lint": "eslint test-app/runtime/src/main/cpp/js",
     "version": "npm run changelog && git add CHANGELOG.md"
   },
   "devDependencies": {
     "conventional-changelog-cli": "^2.1.1",
     "dayjs": "^1.11.7",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
     "semver": "^7.5.0"
   }
 }
diff --git a/test-app/runtime/CMakeLists.txt b/test-app/runtime/CMakeLists.txt
index 63a33e196..a3b715b0b 100644
--- a/test-app/runtime/CMakeLists.txt
+++ b/test-app/runtime/CMakeLists.txt
@@ -58,6 +58,41 @@ include_directories(
         src/main/cpp/ada
 )
 
+# The runtime's builtin JavaScript (src/main/cpp/js) embedded into a generated
+# C++ table by tools/js2c.mjs. The list is explicit rather than globbed so that
+# adding a file is a visible build change; --check-dir fails the build when it
+# drifts from the directory contents.
+set(RUNTIME_BUILTIN_JS_DIR ${PROJECT_SOURCE_DIR}/src/main/cpp/js)
+set(RUNTIME_BUILTIN_JS
+        ${RUNTIME_BUILTIN_JS_DIR}/blob-url.js
+        ${RUNTIME_BUILTIN_JS_DIR}/error-events.js
+        ${RUNTIME_BUILTIN_JS_DIR}/events.js
+        ${RUNTIME_BUILTIN_JS_DIR}/json-helper.js
+        ${RUNTIME_BUILTIN_JS_DIR}/message-loop-timer.js
+        ${RUNTIME_BUILTIN_JS_DIR}/require-factory.js
+        ${RUNTIME_BUILTIN_JS_DIR}/smart-stringify.js
+        ${RUNTIME_BUILTIN_JS_DIR}/weak-ref.js
+)
+set(RUNTIME_BUILTINS_GENERATED_DIR ${PROJECT_SOURCE_DIR}/src/main/cpp/generated)
+get_filename_component(RUNTIME_BUILTINS_JS2C ${PROJECT_SOURCE_DIR}/../../tools/js2c.mjs ABSOLUTE)
+
+find_program(NODE_EXECUTABLE NAMES node nodejs)
+if (NOT NODE_EXECUTABLE)
+    message(FATAL_ERROR "node was not found on PATH; it is required to generate RuntimeBuiltins")
+endif ()
+
+add_custom_command(
+        OUTPUT ${RUNTIME_BUILTINS_GENERATED_DIR}/RuntimeBuiltins.h
+               ${RUNTIME_BUILTINS_GENERATED_DIR}/RuntimeBuiltins.cpp
+        COMMAND ${NODE_EXECUTABLE} ${RUNTIME_BUILTINS_JS2C}
+                --out-dir ${RUNTIME_BUILTINS_GENERATED_DIR}
+                --check-dir ${RUNTIME_BUILTIN_JS_DIR}
+                ${RUNTIME_BUILTIN_JS}
+        DEPENDS ${RUNTIME_BUILTIN_JS} ${RUNTIME_BUILTINS_JS2C}
+        COMMENT "Generating RuntimeBuiltins from src/main/cpp/js"
+        VERBATIM
+)
+
 if (OPTIMIZED_BUILD OR OPTIMIZED_WITH_INSPECTOR_BUILD)
     set(CMAKE_CXX_FLAGS "${COMMON_CMAKE_ARGUMENTS} -O3 -fvisibility=hidden -ffunction-sections -fno-data-sections")
 else ()
@@ -99,6 +134,7 @@ add_library(
         src/main/cpp/ArrayElementAccessor.cpp
         src/main/cpp/ArrayHelper.cpp
         src/main/cpp/AssetExtractor.cpp
+        src/main/cpp/BuiltinLoader.cpp
         src/main/cpp/CallbackHandlers.cpp
         src/main/cpp/ConcurrentQueue.cpp
         src/main/cpp/Constants.cpp
@@ -158,6 +194,8 @@ add_library(
         src/main/cpp/HMRSupport.cpp
         src/main/cpp/DevFlags.cpp
 
+        ${RUNTIME_BUILTINS_GENERATED_DIR}/RuntimeBuiltins.cpp
+
         # V8 inspector source files will be included only in Release mode
         ${INSPECTOR_SOURCES}
 )
diff --git a/test-app/runtime/src/main/cpp/BuiltinLoader.cpp b/test-app/runtime/src/main/cpp/BuiltinLoader.cpp
new file mode 100644
index 000000000..e9498555c
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/BuiltinLoader.cpp
@@ -0,0 +1,116 @@
+#include "BuiltinLoader.h"
+
+#include <mutex>
+#include <vector>
+
+#include "ArgConverter.h"
+
+using namespace v8;
+
+namespace tns {
+
+namespace {
+
+/*
+ * Process-wide bytecode cache shared across isolates. Worker runtimes
+ * initialize on their own threads, so every access is under the mutex.
+ */
+std::mutex builtinCacheMutex;
+std::vector<uint8_t> builtinCache[static_cast<unsigned>(BuiltinId::kCount)];
+
+/*
+ * Every builtin is compiled as a function body receiving these fixed
+ * parameters, mirroring Node's module wrapper: a file exports through
+ * `module.exports`/`exports`, and natives arrive as properties of the
+ * `binding` bag (Node's internalBinding idiom) for each file to destructure.
+ */
+constexpr const char* kExportsParamName = "exports";
+constexpr const char* kModuleParamName = "module";
+constexpr const char* kBindingParamName = "binding";
+constexpr size_t kParamCount = 3;
+
+MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
+    Isolate* isolate = v8::Isolate::GetCurrent();
+    const BuiltinSource& builtin = GetBuiltinSource(id);
+    const unsigned index = static_cast<unsigned>(id);
+
+    // Copy the blob out so the shared slot can be refreshed concurrently while
+    // this compile still reads from the copy.
+    std::vector<uint8_t> blob;
+    {
+        std::lock_guard<std::mutex> lock(builtinCacheMutex);
+        blob = builtinCache[index];
+    }
+
+    ScriptOrigin origin(ArgConverter::ConvertToV8String(isolate, builtin.name));
+    Local<v8::String> sourceText = ArgConverter::ConvertToV8String(
+            isolate, builtin.source, static_cast<int>(builtin.length));
+    Local<v8::String> params[] = {
+            ArgConverter::ConvertToV8String(isolate, kExportsParamName),
+            ArgConverter::ConvertToV8String(isolate, kModuleParamName),
+            ArgConverter::ConvertToV8String(isolate, kBindingParamName)};
+
+    Local<v8::Function> fn;
+    if (!blob.empty()) {
+        // The Source owns and deletes the CachedData object; BufferNotOwned
+        // keeps the underlying bytes (our copy) out of its hands.
+        auto* cachedData = new ScriptCompiler::CachedData(
+                blob.data(), static_cast<int>(blob.size()),
+                ScriptCompiler::CachedData::BufferNotOwned);
+        ScriptCompiler::Source source(sourceText, origin, cachedData);
+        if (ScriptCompiler::CompileFunction(context, &source, kParamCount, params, 0, nullptr,
+                                            ScriptCompiler::kConsumeCodeCache)
+                    .ToLocal(&fn) &&
+            !cachedData->rejected) {
+            return fn;
+        }
+        // Rejected cache (e.g. produced under different flags): fall through
+        // and recompile eagerly so the refreshed blob covers inner functions
+        // again.
+    }
+
+    ScriptCompiler::Source source(sourceText, origin);
+    if (!ScriptCompiler::CompileFunction(context, &source, kParamCount, params, 0, nullptr,
+                                         ScriptCompiler::kEagerCompile)
+                 .ToLocal(&fn)) {
+        return MaybeLocal<v8::Function>();
+    }
+
+    std::unique_ptr<ScriptCompiler::CachedData> produced(
+            ScriptCompiler::CreateCodeCacheForFunction(fn));
+    if (produced != nullptr && produced->data != nullptr && produced->length > 0) {
+        std::lock_guard<std::mutex> lock(builtinCacheMutex);
+        builtinCache[index].assign(produced->data, produced->data + produced->length);
+    }
+
+    return fn;
+}
+
+}  // namespace
+
+MaybeLocal<Value> BuiltinLoader::RunBuiltin(Local<Context> context, BuiltinId id,
+                                            Local<Value> binding) {
+    Isolate* isolate = v8::Isolate::GetCurrent();
+
+    Local<v8::Function> fn;
+    if (!CompileBuiltin(context, id).ToLocal(&fn)) {
+        return MaybeLocal<Value>();
+    }
+
+    Local<Object> exportsObj = Object::New(isolate);
+    Local<Object> moduleObj = Object::New(isolate);
+    Local<v8::String> exportsKey = ArgConverter::ConvertToV8String(isolate, kExportsParamName);
+    if (!moduleObj->Set(context, exportsKey, exportsObj).FromMaybe(false)) {
+        return MaybeLocal<Value>();
+    }
+
+    Local<Value> args[] = {exportsObj, moduleObj,
+                           binding.IsEmpty() ? Undefined(isolate).As<Value>() : binding};
+    if (fn->Call(context, Undefined(isolate), static_cast<int>(kParamCount), args).IsEmpty()) {
+        return MaybeLocal<Value>();
+    }
+
+    return moduleObj->Get(context, exportsKey);
+}
+
+}  // namespace tns
diff --git a/test-app/runtime/src/main/cpp/BuiltinLoader.h b/test-app/runtime/src/main/cpp/BuiltinLoader.h
new file mode 100644
index 000000000..944e07684
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/BuiltinLoader.h
@@ -0,0 +1,29 @@
+#ifndef BUILTINLOADER_H_
+#define BUILTINLOADER_H_
+
+#include "generated/RuntimeBuiltins.h"
+#include "v8.h"
+
+namespace tns {
+
+class BuiltinLoader {
+public:
+    /*
+     * Compiles the builtin identified by id as a function body with the fixed
+     * parameters `exports`, `module` and `binding` (Node's module wrapper plus
+     * its internalBinding idiom), calls it with the given bag of natives (or
+     * undefined when omitted), and returns the resulting `module.exports`.
+     * Scripts carry an "internal/<name>.js" origin so runtime frames are
+     * identifiable in stack traces. Compilation goes through a process-wide
+     * bytecode cache: the first run in the process compiles eagerly and
+     * populates the cache, later isolates (workers, which run on their own
+     * threads) consume it instead of re-parsing the source.
+     */
+    static v8::MaybeLocal<v8::Value> RunBuiltin(
+            v8::Local<v8::Context> context, BuiltinId id,
+            v8::Local<v8::Value> binding = v8::Local<v8::Value>());
+};
+
+}  // namespace tns
+
+#endif /* BUILTINLOADER_H_ */
diff --git a/test-app/runtime/src/main/cpp/ErrorEvents.cpp b/test-app/runtime/src/main/cpp/ErrorEvents.cpp
index 071c53b6e..b41ff1486 100644
--- a/test-app/runtime/src/main/cpp/ErrorEvents.cpp
+++ b/test-app/runtime/src/main/cpp/ErrorEvents.cpp
@@ -1,6 +1,7 @@
 #include "ErrorEvents.h"
 
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "NativeScriptAssert.h"
 #include "NativeScriptException.h"
 #include "Runtime.h"
@@ -19,7 +20,7 @@ static Runtime* GetRuntimeOrNull(Isolate* isolate) {
 }
 
 /*
- * Native function handed to the bootstrap IIFE as `nativeReportFatal(error,
+ * Native function handed to internal/error-events.js as `nativeReportFatal(error,
  * stackString)`. It runs the terminal tail (shim + log) WITHOUT re-dispatching
  * an event: reportError and listener-thrown errors have already gone through
  * JS dispatch, so dispatching again here would recurse.
@@ -36,111 +37,6 @@ static void NativeReportFatalCallback(const FunctionCallbackInfo<Value>& info) {
 }
 
 void ErrorEvents::Init(Local<Context> context) {
-    /*
-     * WHATWG error-events layer, layered on top of the generic event
-     * primitives installed by Events::Init and ported from the iOS runtime.
-     * Plain (module-free) script, strict inside the IIFE, ES5-ish so it never
-     * depends on other runtime extensions. The IIFE is invoked with two
-     * arguments - the internal EventTarget backing the global (so native
-     * dispatch survives app code overwriting globalThis.dispatchEvent) and
-     * the native nativeReportFatal(error, stack) function that runs the
-     * terminal tail - and returns three closures bound to that backing store.
-     * ErrorEvent/PromiseRejectionEvent subclass the Event captured off
-     * globalThis at init time, which runs before any user code.
-     */
-    auto source = R"js(
-    (function (globalTarget, nativeReportFatal) {
-      "use strict";
-      var g = globalThis;
-      var Event = g.Event;
-
-      function ErrorEvent(type, opts) {
-        opts = opts || {};
-        Event.call(this, type, opts);
-        this.message = opts.message !== undefined ? String(opts.message) : "";
-        this.filename = opts.filename !== undefined ? String(opts.filename) : "";
-        this.lineno = opts.lineno !== undefined ? (opts.lineno | 0) : 0;
-        this.colno = opts.colno !== undefined ? (opts.colno | 0) : 0;
-        this.error = opts.error !== undefined ? opts.error : null;
-      }
-      ErrorEvent.prototype = Object.create(Event.prototype);
-      ErrorEvent.prototype.constructor = ErrorEvent;
-
-      function PromiseRejectionEvent(type, opts) {
-        opts = opts || {};
-        Event.call(this, type, opts);
-        this.promise = opts.promise;
-        this.reason = opts.reason;
-      }
-      PromiseRejectionEvent.prototype = Object.create(Event.prototype);
-      PromiseRejectionEvent.prototype.constructor = PromiseRejectionEvent;
-
-      // A listener that throws must not stop other listeners: route the thrown
-      // value to the native fatal tail instead of ever recursively dispatching
-      // another `error` event from inside dispatch.
-      globalTarget._installListenerErrorReporter(function (e) {
-        try { nativeReportFatal(e, (e && e.stack) || ""); } catch (ignored) {}
-      });
-
-      g.reportError = function (e) {
-        if (arguments.length === 0) {
-          throw new TypeError("Failed to execute 'reportError': 1 argument required, but only 0 present.");
-        }
-        var ev = new ErrorEvent("error", {
-          message: (e && e.message !== undefined && e.message !== null) ? String(e.message) : String(e),
-          error: e,
-          cancelable: true
-        });
-        if (globalTarget.dispatchEvent(ev)) {
-          nativeReportFatal(e, (e && e.stack) || "");
-        }
-      };
-
-      g.ErrorEvent = ErrorEvent;
-      g.PromiseRejectionEvent = PromiseRejectionEvent;
-
-      // Closures called by C++. They never look up globalThis.dispatchEvent,
-      // so they keep working even if app code overwrites it.
-      function dispatchErrorEvent(error, message, stack) {
-        var ev = new ErrorEvent("error", {
-          message: message !== undefined && message !== null ? String(message) : "",
-          error: error,
-          cancelable: true
-        });
-        globalTarget.dispatchEvent(ev);
-        return ev.defaultPrevented;
-      }
-      function dispatchUnhandledRejection(promise, reason) {
-        var ev = new PromiseRejectionEvent("unhandledrejection", {
-          promise: promise,
-          reason: reason,
-          cancelable: true
-        });
-        globalTarget.dispatchEvent(ev);
-        return ev.defaultPrevented;
-      }
-      function dispatchRejectionHandled(promise, reason) {
-        var ev = new PromiseRejectionEvent("rejectionhandled", {
-          promise: promise,
-          reason: reason,
-          cancelable: false
-        });
-        globalTarget.dispatchEvent(ev);
-      }
-      function dispatchNativeUncaughtError(error, message, stack) {
-        var ev = new ErrorEvent("nativeuncaughterror", {
-          message: message !== undefined && message !== null ? String(message) : "",
-          error: error,
-          cancelable: true
-        });
-        globalTarget.dispatchEvent(ev);
-        return ev.defaultPrevented;
-      }
-
-      return [dispatchErrorEvent, dispatchUnhandledRejection, dispatchRejectionHandled, dispatchNativeUncaughtError];
-    })
-    )js";
-
     auto isolate = v8::Isolate::GetCurrent();
     auto runtime = GetRuntimeOrNull(isolate);
     if (runtime == nullptr) {
@@ -149,34 +45,25 @@ void ErrorEvents::Init(Local<Context> context) {
     if (runtime->GlobalEventTarget().IsEmpty()) {
         throw NativeScriptException("ErrorEvents::Init: Events::Init must run first");
     }
-    Local<Object> globalTarget = runtime->GlobalEventTarget().Get(isolate);
-
-    Local<Script> script;
-    if (!Script::Compile(context, ArgConverter::ConvertToV8String(isolate, source))
-                 .ToLocal(&script)) {
-        throw NativeScriptException("ErrorEvents::Init: failed to compile the error-events bootstrap");
-    }
-
-    Local<Value> result;
-    if (!script->Run(context).ToLocal(&result) || !result->IsFunction()) {
-        throw NativeScriptException("ErrorEvents::Init: failed to evaluate the error-events bootstrap");
-    }
 
     Local<Function> nativeReportFatal;
     if (!Function::New(context, NativeReportFatalCallback).ToLocal(&nativeReportFatal)) {
         throw NativeScriptException("ErrorEvents::Init: failed to create nativeReportFatal");
     }
 
-    Local<Value> installArgs[] = {globalTarget, nativeReportFatal};
-    Local<Value> iifeResult;
-    if (!result.As<Function>()
-                 ->Call(context, context->Global(), 2, installArgs)
-                 .ToLocal(&iifeResult) ||
-        !iifeResult->IsArray()) {
+    Local<Object> binding = Object::New(isolate);
+    binding->Set(context, ArgConverter::ConvertToV8String(isolate, "globalTarget"),
+                 runtime->GlobalEventTarget().Get(isolate));
+    binding->Set(context, ArgConverter::ConvertToV8String(isolate, "nativeReportFatal"),
+                 nativeReportFatal);
+
+    Local<Value> result;
+    if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kErrorEvents, binding).ToLocal(&result) ||
+        !result->IsArray()) {
         throw NativeScriptException("ErrorEvents::Init: the error-events bootstrap did not return the dispatch closures");
     }
 
-    auto closures = iifeResult.As<Array>();
+    auto closures = result.As<Array>();
     Local<Value> errorFn, rejectionFn, handledFn, nativeUncaughtFn;
     if (!closures->Get(context, 0).ToLocal(&errorFn) || !errorFn->IsFunction() ||
         !closures->Get(context, 1).ToLocal(&rejectionFn) || !rejectionFn->IsFunction() ||
diff --git a/test-app/runtime/src/main/cpp/ErrorEvents.h b/test-app/runtime/src/main/cpp/ErrorEvents.h
index 624c7b051..5c5e8e001 100644
--- a/test-app/runtime/src/main/cpp/ErrorEvents.h
+++ b/test-app/runtime/src/main/cpp/ErrorEvents.h
@@ -15,12 +15,12 @@ class ErrorEvents {
      * (subclassing the Event installed by Events::Init, captured off
      * globalThis at init time) and global reportError. Evaluated once per
      * isolate during PrepareV8Runtime, right after Events::Init, for both the
-     * main and worker isolates. The bootstrap IIFE is invoked with the backing
+     * main and worker isolates. internal/error-events.js receives the backing
      * event target (Runtime::GlobalEventTarget()) and the native
-     * nativeReportFatal(error, stack) function, and returns three closures
-     * bound to the internal listener store; they are stashed on the Runtime
-     * so native dispatch survives app code overwriting
-     * globalThis.dispatchEvent.
+     * nativeReportFatal(error, stack) function through its binding bag, and
+     * exports the dispatch closures bound to the internal listener store; they
+     * are stashed on the Runtime so native dispatch survives app code
+     * overwriting globalThis.dispatchEvent.
      */
     static void Init(v8::Local<v8::Context> context);
 
diff --git a/test-app/runtime/src/main/cpp/Events.cpp b/test-app/runtime/src/main/cpp/Events.cpp
index 4086a34c3..7aaeffecd 100644
--- a/test-app/runtime/src/main/cpp/Events.cpp
+++ b/test-app/runtime/src/main/cpp/Events.cpp
@@ -1,6 +1,6 @@
 #include "Events.h"
 
-#include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "NativeScriptException.h"
 #include "Runtime.h"
 
@@ -9,148 +9,6 @@ using namespace tns;
 using namespace v8;
 
 void Events::Init(Local<Context> context) {
-    /*
-     * Generic WHATWG event primitives, ported from the iOS runtime. Plain
-     * (module-free) script, strict inside the IIFE, ES5-ish so it never
-     * depends on other runtime extensions. The IIFE installs Event/EventTarget
-     * and the global EventTarget methods, then returns the internal
-     * EventTarget instance backing the global so native dispatch survives app
-     * code overwriting globalThis.dispatchEvent. The error-events layer
-     * (ErrorEvents::Init) runs immediately after and installs the native
-     * listener-error reporter through _installListenerErrorReporter.
-     */
-    auto source = R"js(
-    (function () {
-      "use strict";
-      var g = globalThis;
-
-      function Event(type, opts) {
-        opts = opts || {};
-        this.type = String(type);
-        this.bubbles = !!opts.bubbles;
-        this.cancelable = !!opts.cancelable;
-        this.composed = !!opts.composed;
-        this.defaultPrevented = false;
-        this.target = null;
-        this.currentTarget = null;
-        this._stopPropagation = false;
-        this._stopImmediate = false;
-      }
-      Event.prototype.preventDefault = function () {
-        if (this.cancelable) { this.defaultPrevented = true; }
-      };
-      Event.prototype.stopPropagation = function () { this._stopPropagation = true; };
-      Event.prototype.stopImmediatePropagation = function () {
-        this._stopPropagation = true;
-        this._stopImmediate = true;
-      };
-
-      // A listener that throws must not stop other listeners: route the thrown
-      // value to the native fatal tail instead of ever recursively dispatching
-      // another `error` event from inside dispatch. The error-events layer
-      // installs the real reporter via _installListenerErrorReporter (before
-      // any user code runs); until then a thrown listener is swallowed.
-      var reportListenerError = function (e) {};
-
-      function EventTargetImpl() { this._listeners = Object.create(null); }
-      EventTargetImpl.prototype.addEventListener = function (type, callback, options) {
-        if (callback === null || callback === undefined) { return; }
-        type = String(type);
-        var capture = false, once = false;
-        if (typeof options === "boolean") {
-          capture = options;
-        } else if (options && typeof options === "object") {
-          capture = !!options.capture;
-          once = !!options.once;
-        }
-        var list = this._listeners[type];
-        if (!list) { list = this._listeners[type] = []; }
-        for (var i = 0; i < list.length; i++) {
-          if (list[i].callback === callback && list[i].capture === capture) { return; }
-        }
-        list.push({ callback: callback, once: once, capture: capture });
-      };
-      EventTargetImpl.prototype.removeEventListener = function (type, callback, options) {
-        type = String(type);
-        var capture = false;
-        if (typeof options === "boolean") {
-          capture = options;
-        } else if (options && typeof options === "object") {
-          capture = !!options.capture;
-        }
-        var list = this._listeners[type];
-        if (!list) { return; }
-        for (var i = 0; i < list.length; i++) {
-          if (list[i].callback === callback && list[i].capture === capture) {
-            list.splice(i, 1);
-            return;
-          }
-        }
-      };
-      EventTargetImpl.prototype.dispatchEvent = function (event) {
-        event.target = this;
-        event.currentTarget = this;
-        var list = this._listeners[event.type];
-        if (list) {
-          // Snapshot so listeners added during dispatch are not invoked and
-          // registration order is preserved.
-          var snapshot = list.slice();
-          for (var i = 0; i < snapshot.length; i++) {
-            var entry = snapshot[i];
-            var idx = list.indexOf(entry);
-            if (idx === -1) { continue; }  // removed since snapshot
-            if (entry.once) { list.splice(idx, 1); }
-            var cb = entry.callback;
-            try {
-              if (typeof cb === "function") {
-                cb.call(this, event);
-              } else if (cb && typeof cb.handleEvent === "function") {
-                cb.handleEvent(event);
-              }
-            } catch (e) {
-              reportListenerError(e);
-            }
-            if (event._stopImmediate) { break; }
-          }
-        }
-        event.currentTarget = null;
-        return !event.defaultPrevented;
-      };
-
-      // Internal EventTarget instance backing the global. globalThis's
-      // prototype is intentionally NOT made an EventTarget; only the three
-      // methods are bound onto it.
-      var globalTarget = new EventTargetImpl();
-      // Called by the error-events layer to install the native listener-error
-      // reporter into this closure. One-shot: the backing target leaks to app
-      // code via event.target, so the hook removes itself after the install
-      // (which happens during runtime init, before any user code runs).
-      globalTarget._installListenerErrorReporter = function (fn) {
-        reportListenerError = fn;
-        delete globalTarget._installListenerErrorReporter;
-      };
-      g.addEventListener = function (type, callback, options) {
-        return globalTarget.addEventListener(type, callback, options);
-      };
-      g.removeEventListener = function (type, callback, options) {
-        return globalTarget.removeEventListener(type, callback, options);
-      };
-      g.dispatchEvent = function (event) {
-        return globalTarget.dispatchEvent(event);
-      };
-
-      function EventTarget() { EventTargetImpl.call(this); }
-      EventTarget.prototype.addEventListener = EventTargetImpl.prototype.addEventListener;
-      EventTarget.prototype.removeEventListener = EventTargetImpl.prototype.removeEventListener;
-      EventTarget.prototype.dispatchEvent = EventTargetImpl.prototype.dispatchEvent;
-
-      g.Event = Event;
-      g.EventTarget = EventTarget;
-
-      return globalTarget;
-    })
-    )js";
-
     auto isolate = v8::Isolate::GetCurrent();
     auto runtime = static_cast<Runtime*>(
             isolate->GetData((uint32_t) Runtime::IsolateData::RUNTIME));
@@ -158,24 +16,11 @@ void Events::Init(Local<Context> context) {
         throw NativeScriptException("Events::Init: no runtime for isolate");
     }
 
-    Local<Script> script;
-    if (!Script::Compile(context, ArgConverter::ConvertToV8String(isolate, source))
-                 .ToLocal(&script)) {
-        throw NativeScriptException("Events::Init: failed to compile the event-primitives bootstrap");
-    }
-
     Local<Value> result;
-    if (!script->Run(context).ToLocal(&result) || !result->IsFunction()) {
-        throw NativeScriptException("Events::Init: failed to evaluate the event-primitives bootstrap");
-    }
-
-    Local<Value> iifeResult;
-    if (!result.As<Function>()
-                 ->Call(context, context->Global(), 0, nullptr)
-                 .ToLocal(&iifeResult) ||
-        !iifeResult->IsObject()) {
+    if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kEvents).ToLocal(&result) ||
+        !result->IsObject()) {
         throw NativeScriptException("Events::Init: the event-primitives bootstrap did not return the backing target");
     }
 
-    runtime->GlobalEventTarget().Reset(isolate, iifeResult.As<Object>());
+    runtime->GlobalEventTarget().Reset(isolate, result.As<Object>());
 }
diff --git a/test-app/runtime/src/main/cpp/IsolateDisposer.cpp b/test-app/runtime/src/main/cpp/IsolateDisposer.cpp
index c495f0dbe..a322edefc 100644
--- a/test-app/runtime/src/main/cpp/IsolateDisposer.cpp
+++ b/test-app/runtime/src/main/cpp/IsolateDisposer.cpp
@@ -4,6 +4,7 @@
 
 #include "IsolateDisposer.h"
 #include "ArgConverter.h"
+#include "JSONObjectHelper.h"
 #include "MetadataNode.h"
 #include "V8GlobalHelpers.h"
 #include <console/Console.h>
@@ -16,6 +17,7 @@ namespace tns {
         tns::MetadataNode::onDisposeIsolate(isolate);
         tns::V8GlobalHelpers::onDisposeIsolate(isolate);
         tns::Console::onDisposeIsolate(isolate);
+        tns::JSONObjectHelper::onDisposeIsolate(isolate);
         // clear all isolate bound objects
         std::lock_guard<std::mutex> lock(isolateBoundObjectsMutex_);
         auto it = isolateBoundObjects_.find(isolate);
diff --git a/test-app/runtime/src/main/cpp/JSONObjectHelper.cpp b/test-app/runtime/src/main/cpp/JSONObjectHelper.cpp
index a37a7706b..88cb8f9f3 100644
--- a/test-app/runtime/src/main/cpp/JSONObjectHelper.cpp
+++ b/test-app/runtime/src/main/cpp/JSONObjectHelper.cpp
@@ -1,12 +1,16 @@
 #include "NativeScriptException.h"
 #include "JSONObjectHelper.h"
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
+#include "robin_hood.h"
 #include <sstream>
 #include <string>
 
 using namespace v8;
 using namespace tns;
 
+static robin_hood::unordered_map<Isolate*, Persistent<Function>*> isolateToSerializeFunc;
+
 void JSONObjectHelper::RegisterFromFunction(Isolate *isolate, Local<Value>& jsonObject) {
     if (!jsonObject->IsFunction()) {
         return;
@@ -24,7 +28,11 @@ void JSONObjectHelper::RegisterFromFunction(Isolate *isolate, Local<Value>& json
         return;
     }
 
-    Persistent<Function>* serializeFunc = new Persistent<Function>(isolate, CreateSerializeFunc(context));
+    Persistent<Function>* serializeFunc = GetSerializeFunc(context);
+    if (serializeFunc == nullptr) {
+        return;
+    }
+
     Local<External> extData = External::New(isolate, serializeFunc, v8::kExternalPointerTypeTagDefault);
     Local<Function> fromFunc;
     bool ok = FunctionTemplate::New(isolate, ConvertCallbackStatic, extData)->GetFunction(context).ToLocal(&fromFunc);
@@ -68,47 +76,35 @@ void JSONObjectHelper::ConvertCallbackStatic(const FunctionCallbackInfo<Value>&
     }
 }
 
-Local<Function> JSONObjectHelper::CreateSerializeFunc(Local<Context> context) {
-    std::string source =
-        "(() => function serialize(data) {"
-        "    let store;"
-        "    switch (typeof data) {"
-        "        case \"string\":"
-        "        case \"boolean\":"
-        "        case \"number\": {"
-        "            return data;"
-        "        }"
-        "        case \"object\": {"
-        "            if (!data) {"
-        "                return null;"
-        "            }"
-        ""
-        "            if (data instanceof Date) {"
-        "                return data.toJSON();"
-        "            }"
-        ""
-        "            if (Array.isArray(data)) {"
-        "                store = new org.json.JSONArray();"
-        "                data.forEach((item) => store.put(serialize(item)));"
-        "                return store;"
-        "            }"
-        ""
-        "            store = new org.json.JSONObject();"
-        "            Object.keys(data).forEach((key) => store.put(key, serialize(data[key])));"
-        "            return store;"
-        "        }"
-        "        default:"
-        "            return null;"
-        "    }"
-        "})()";
-
+/*
+ * The JS->org.json serializer is shared by every `from` function created on
+ * this isolate; it holds no per-call state, so it is compiled once and kept
+ * alive for the isolate's lifetime.
+ */
+Persistent<Function>* JSONObjectHelper::GetSerializeFunc(Local<Context> context) {
     Isolate* isolate = v8::Isolate::GetCurrent();
 
-    Local<Script> script = Script::Compile(context, ArgConverter::ConvertToV8String(isolate, source)).ToLocalChecked();
+    auto it = isolateToSerializeFunc.find(isolate);
+    if (it != isolateToSerializeFunc.end()) {
+        return it->second;
+    }
 
-    Local<Value> result = script->Run(context).ToLocalChecked();
+    Local<Value> result;
+    if (!BuiltinLoader::RunBuiltin(context, BuiltinId::kJsonHelper).ToLocal(&result) ||
+            !result->IsFunction()) {
+        return nullptr;
+    }
 
-    Local<Function> serializeFunc = result.As<Function>();
+    auto* serializeFunc = new Persistent<Function>(isolate, result.As<Function>());
+    isolateToSerializeFunc.emplace(isolate, serializeFunc);
 
     return serializeFunc;
 }
+
+void JSONObjectHelper::onDisposeIsolate(Isolate* isolate) {
+    auto it = isolateToSerializeFunc.find(isolate);
+    if (it != isolateToSerializeFunc.end()) {
+        delete it->second;
+        isolateToSerializeFunc.erase(it);
+    }
+}
diff --git a/test-app/runtime/src/main/cpp/JSONObjectHelper.h b/test-app/runtime/src/main/cpp/JSONObjectHelper.h
index 1597e3551..8aeb4d02f 100644
--- a/test-app/runtime/src/main/cpp/JSONObjectHelper.h
+++ b/test-app/runtime/src/main/cpp/JSONObjectHelper.h
@@ -8,8 +8,9 @@ namespace tns {
 class JSONObjectHelper {
 public:
     static void RegisterFromFunction(v8::Isolate *isolate, v8::Local<v8::Value>& jsonObject);
+    static void onDisposeIsolate(v8::Isolate* isolate);
 private:
-    static v8::Local<v8::Function> CreateSerializeFunc(v8::Local<v8::Context> context);
+    static v8::Persistent<v8::Function>* GetSerializeFunc(v8::Local<v8::Context> context);
     static void ConvertCallbackStatic(const v8::FunctionCallbackInfo<v8::Value>& info);
 };
 
diff --git a/test-app/runtime/src/main/cpp/MessageLoopTimer.cpp b/test-app/runtime/src/main/cpp/MessageLoopTimer.cpp
index bd8c5c5dc..45bf50f29 100644
--- a/test-app/runtime/src/main/cpp/MessageLoopTimer.cpp
+++ b/test-app/runtime/src/main/cpp/MessageLoopTimer.cpp
@@ -6,6 +6,7 @@
 #include "include/libplatform/libplatform.h"
 #include "NativeScriptAssert.h"
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "Runtime.h"
 
 using namespace tns;
@@ -14,62 +15,8 @@ using namespace v8;
 static const int SLEEP_INTERVAL_MS = 100;
 
 void MessageLoopTimer::Init(Local<Context> context) {
-    this->RegisterStartStopFunctions(context);
-
-    std::string proxyScript = R"(
-        (function () {
-            // We proxy the WebAssembly's compile, compileStreaming, instantiate and
-            // instantiateStreaming methods so that they can start and stop a
-            // MessageLoopTimer inside the promise callbacks. This timer will call
-            // the v8::platform::PumpMessageLoop method at regular intervals.
-            // https://github.com/NativeScript/android-runtime/issues/1558
-
-            global.WebAssembly = new Proxy(WebAssembly, {
-                get: (target, name) => {
-                    let origMethod = target[name];
-                    let proxyMethods = [
-                        "compile",
-                        "compileStreaming",
-                        "instantiate",
-                        "instantiateStreaming"
-                    ];
-
-                    if (proxyMethods.indexOf(name) < 0) {
-                        return origMethod;
-                    }
-
-                    return function (...args) {
-                        __messageLoopTimerStart();
-                        let result = origMethod.apply(this, args);
-                        return result.then(x => {
-                            __messageLoopTimerStop();
-                            return x;
-                        }).catch(e => {
-                            __messageLoopTimerStop();
-                            throw e;
-                        });
-                    };
-                }
-            });
-        })();
-    )";
-
     Isolate* isolate = v8::Isolate::GetCurrent();
 
-    auto source = ArgConverter::ConvertToV8String(isolate, proxyScript);
-    Local<Script> script;
-    bool success = Script::Compile(context, source).ToLocal(&script);
-    assert(success && !script.IsEmpty());
-
-    Local<Value> result;
-    success = script->Run(context).ToLocal(&result);
-    assert(success);
-}
-
-void MessageLoopTimer::RegisterStartStopFunctions(Local<Context> context) {
-    Isolate* isolate = v8::Isolate::GetCurrent();
-    Local<Object> global = context->Global();
-
     Local<External> ext = External::New(isolate, this, v8::kExternalPointerTypeTagDefault);
     Local<Function> startFunc;
     Local<Function> stopFunc;
@@ -78,8 +25,12 @@ void MessageLoopTimer::RegisterStartStopFunctions(Local<Context> context) {
     success = Function::New(context, MessageLoopTimer::StopCallback, ext).ToLocal(&stopFunc);
     assert(success);
 
-    global->Set(context, ArgConverter::ConvertToV8String(isolate, "__messageLoopTimerStart"), startFunc);
-    global->Set(context, ArgConverter::ConvertToV8String(isolate, "__messageLoopTimerStop"), stopFunc);
+    Local<Object> binding = Object::New(isolate);
+    binding->Set(context, ArgConverter::ConvertToV8String(isolate, "messageLoopTimerStart"), startFunc);
+    binding->Set(context, ArgConverter::ConvertToV8String(isolate, "messageLoopTimerStop"), stopFunc);
+
+    success = !BuiltinLoader::RunBuiltin(context, BuiltinId::kMessageLoopTimer, binding).IsEmpty();
+    assert(success);
 }
 
 void MessageLoopTimer::StartCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
diff --git a/test-app/runtime/src/main/cpp/MessageLoopTimer.h b/test-app/runtime/src/main/cpp/MessageLoopTimer.h
index e234e5d13..8bdb929ca 100644
--- a/test-app/runtime/src/main/cpp/MessageLoopTimer.h
+++ b/test-app/runtime/src/main/cpp/MessageLoopTimer.h
@@ -12,7 +12,6 @@ class MessageLoopTimer {
     bool m_isRunning;
     int m_fd[2];
 
-    void RegisterStartStopFunctions(v8::Local<v8::Context> context);
     static void StartCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
     static void StopCallback(const v8::FunctionCallbackInfo<v8::Value>& info);
     static int PumpMessageLoopCallback(int fd, int events, void* data);
diff --git a/test-app/runtime/src/main/cpp/ModuleInternal.cpp b/test-app/runtime/src/main/cpp/ModuleInternal.cpp
index ef9a2faae..dec5a0465 100644
--- a/test-app/runtime/src/main/cpp/ModuleInternal.cpp
+++ b/test-app/runtime/src/main/cpp/ModuleInternal.cpp
@@ -6,6 +6,7 @@
  */
 #include "ModuleInternal.h"
 #include "ModuleInternalCallbacks.h"
+#include "BuiltinLoader.h"
 #include "File.h"
 #include "JniLocalRef.h"
 #include "ArgConverter.h"
@@ -80,36 +81,14 @@ void ModuleInternal::Init(Isolate* isolate, const string& baseDir) {
 
     m_isolate = isolate;
 
-    string requireFactoryScript =
-        "(function () { "
-        "	function require_factory(requireInternal, dirName) { "
-        "		return function require(modulePath) { "
-        "			if(global.__requireOverride) { "
-        "				var result = global.__requireOverride(modulePath, dirName); "
-        "				if(result) { "
-        "					return result; "
-        "				} "
-        "			} "
-        "			return requireInternal(modulePath, dirName); "
-        "		} "
-        "	} "
-        "	return require_factory; "
-        "})()";
-
-    auto source = ArgConverter::ConvertToV8String(isolate, requireFactoryScript);
     auto context = isolate->GetCurrentContext();
 
     auto global = context->Global();
 
-    Local<Script> script;
-    auto maybeScript = Script::Compile(context, source).ToLocal(&script);
-
-    assert(!script.IsEmpty());
-
     Local<Value> result;
-    auto maybeResult = script->Run(context).ToLocal(&result);
+    auto success = BuiltinLoader::RunBuiltin(context, BuiltinId::kRequireFactory).ToLocal(&result);
 
-    assert(!result.IsEmpty() && result->IsFunction());
+    assert(success && result->IsFunction());
 
     auto requireFactoryFunction = result.As<Function>();
 
diff --git a/test-app/runtime/src/main/cpp/Runtime.cpp b/test-app/runtime/src/main/cpp/Runtime.cpp
index 04d106f6e..b463cb728 100644
--- a/test-app/runtime/src/main/cpp/Runtime.cpp
+++ b/test-app/runtime/src/main/cpp/Runtime.cpp
@@ -12,6 +12,7 @@
 
 #include "ArgConverter.h"
 #include "ArrayHelper.h"
+#include "BuiltinLoader.h"
 #include "CallbackHandlers.h"
 #include "Constants.h"
 #include "ErrorEvents.h"
@@ -839,79 +840,11 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath,
 
   Local<Context> context = Context::New(isolate, nullptr, globalTemplate);
 
-  auto blob_methods = R"js(
-    const BLOB_STORE = new Map();
-    URL.createObjectURL = function (object, options = null) {
-        try {
-            if (object instanceof Blob || object instanceof File) {
-                const id = java.util.UUID.randomUUID().toString();
-                const ret = `blob:nativescript/${id}`;
-                BLOB_STORE.set(ret, {
-                    blob: object,
-                    type: object?.type,
-                    ext: options?.ext,
-                });
-                return ret;
-            }
-        } catch (error) {
-            return null;
-        }
-        return null;
-    };
-    URL.revokeObjectURL = function (url) {
-        BLOB_STORE.delete(url);
-    };
-    const InternalAccessor = class {};
-    InternalAccessor.getData = function (url) {
-        return BLOB_STORE.get(url);
-    };
-    URL.InternalAccessor = InternalAccessor;
-    Object.defineProperty(URL.prototype, 'searchParams', {
-        get() {
-            if (this._searchParams == null) {
-                this._searchParams = new URLSearchParams(this.search);
-                Object.defineProperty(this._searchParams, '_url', {
-                    enumerable: false,
-                    writable: false,
-                    value: this,
-                });
-                this._searchParams._append = this._searchParams.append;
-                this._searchParams.append = function (name, value) {
-                    this._append(name, value);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._delete = this._searchParams.delete;
-                this._searchParams.delete = function (name) {
-                    this._delete(name);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._set = this._searchParams.set;
-                this._searchParams.set = function (name, value) {
-                    this._set(name, value);
-                    this._url.search = this.toString();
-                };
-                this._searchParams._sort = this._searchParams.sort;
-                this._searchParams.sort = function () {
-                    this._sort();
-                    this._url.search = this.toString();
-                };
-            }
-            return this._searchParams;
-        },
-    });
-    )js";
-
   auto global = context->Global();
 
   v8::Context::Scope contextScope{context};
 
-  v8::Local<v8::Script> script;
-  v8::Script::Compile(context,
-                      ArgConverter::ConvertToV8String(isolate, blob_methods))
-      .ToLocal(&script);
-
-  v8::Local<v8::Value> out;
-  script->Run(context).ToLocal(&out);
+  BuiltinLoader::RunBuiltin(context, BuiltinId::kBlobUrl);
 
   // Generic WHATWG event primitives (Event/EventTarget + the globalThis
   // mixin), then the error-events layer on top (ErrorEvent/
diff --git a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
index b5fc8830f..4be82634c 100644
--- a/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
+++ b/test-app/runtime/src/main/cpp/V8GlobalHelpers.cpp
@@ -1,5 +1,6 @@
 #include "V8GlobalHelpers.h"
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "CallbackHandlers.h"
 #include "include/v8.h"
 #include "JEnv.h"
@@ -20,41 +21,11 @@ Local<Function> GetSmartJSONStringifyFunction(Isolate* isolate) {
         return smartStringifyPersistentFunction->Get(isolate);
     }
 
-    string smartStringifyFunctionScript =
-        "(function () {\n"
-        "    function smartStringify(object) {\n"
-        "        const seen = [];\n"
-        "        var replacer = function (key, value) {\n"
-        "            if (value != null && typeof value == \"object\") {\n"
-        "                if (seen.indexOf(value) >= 0) {\n"
-        "                    if (key) {\n"
-        "                        return \"[Circular]\";\n"
-        "                    }\n"
-        "                    return;\n"
-        "                }\n"
-        "                seen.push(value);\n"
-        "            }\n"
-        "            return value;\n"
-        "        };\n"
-        "        return JSON.stringify(object, replacer, 2);\n"
-        "    }\n"
-        "    return smartStringify;\n"
-        "})();";
-
-    auto source = tns::ArgConverter::ConvertToV8String(isolate, smartStringifyFunctionScript);
     auto context = isolate->GetCurrentContext();
 
-    Local<Script> script;
-    auto maybeScript = Script::Compile(context, source).ToLocal(&script);
-
-    if (script.IsEmpty()) {
-        return Local<Function>();
-    }
-
     Local<Value> result;
-    auto maybeResult = script->Run(context).ToLocal(&result);
-
-    if (result.IsEmpty() && !result->IsFunction()) {
+    if (!tns::BuiltinLoader::RunBuiltin(context, tns::BuiltinId::kSmartStringify).ToLocal(&result) ||
+            !result->IsFunction()) {
         return Local<Function>();
     }
 
diff --git a/test-app/runtime/src/main/cpp/WeakRef.cpp b/test-app/runtime/src/main/cpp/WeakRef.cpp
index 35850ebf0..d6b429108 100644
--- a/test-app/runtime/src/main/cpp/WeakRef.cpp
+++ b/test-app/runtime/src/main/cpp/WeakRef.cpp
@@ -1,5 +1,6 @@
 #include "WeakRef.h"
 #include "ArgConverter.h"
+#include "BuiltinLoader.h"
 #include "V8StringConstants.h"
 #include "NativeScriptException.h"
 #include "V8GlobalHelpers.h"
@@ -13,25 +14,6 @@ WeakRef::WeakRef() {
 }
 
 void WeakRef::Init(v8::Isolate* isolate, Local<v8::Context> context) {
-    std::string source = R"(
-        // WeakRef polyfills
-        global.WeakRef.prototype.get = global.WeakRef.prototype.deref;
-        global.WeakRef.prototype.__hasWarnedAboutClear = false;
-        global.WeakRef.prototype.clear = () => {
-            if(global.WeakRef.prototype.__hasWarnedAboutClear) {
-                return;
-            }
-            global.WeakRef.prototype.__hasWarnedAboutClear = true;
-            console.warn('WeakRef.clear() is non-standard and has been deprecated. It does nothing and the call can be safely removed.');
-        }
-    )";
-
-    Local<Script> script;
-    bool success = Script::Compile(context, ArgConverter::ConvertToV8String(isolate, source)).ToLocal(&script);
-    assert(success && !script.IsEmpty());
-
-    Local<Value> result;
-    success = script->Run(context).ToLocal(&result);
+    bool success = !BuiltinLoader::RunBuiltin(context, BuiltinId::kWeakRef).IsEmpty();
     assert(success);
-
-}
\ No newline at end of file
+}
diff --git a/test-app/runtime/src/main/cpp/js/README.md b/test-app/runtime/src/main/cpp/js/README.md
new file mode 100644
index 000000000..22a6e0da9
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/README.md
@@ -0,0 +1,46 @@
+# Runtime builtins
+
+The `.js` files in this directory are the runtime's internal JavaScript. At
+build time a CMake custom command runs `tools/js2c.mjs`, which embeds them into
+`test-app/runtime/src/main/cpp/generated/RuntimeBuiltins.cpp`; at runtime
+`BuiltinLoader::RunBuiltin` compiles and executes them with an
+`internal/<name>.js` script origin and a process-wide bytecode cache.
+
+## Contract (Node's module wrapper + internalBinding idiom)
+
+Every file is compiled as a **function body** via `v8::ScriptCompiler::CompileFunction`
+with the fixed parameters `exports`, `module` and `binding`:
+
+```js
+const { someNative, anotherNative } = binding;
+
+module.exports = somethingTheCallSiteNeeds;
+```
+
+- `binding` is a plain object of natives built by the C++ call site; a file
+  that needs nothing from C++ simply doesn't mention it.
+- **`module.exports` is the export channel** — whatever it holds when the file
+  finishes is what `RunBuiltin` hands back to C++ (used for factory functions
+  and init results). Both CommonJS styles work: replace the whole export with
+  `module.exports = x`, or hang properties off `exports`. A file that only
+  installs globals exports nothing and the call site ignores the value.
+- **No top-level `return`.** It would work — these are function bodies — but
+  every tool that isn't reading this repo's ESLint config (editors' TS server,
+  prettier, review bots) rejects the file as invalid JavaScript.
+- Strict mode is per-file: start the file with `"use strict";` to opt in.
+- Destructure `binding` once, at the top of the file, so the file's native
+  dependencies are visible and greppable.
+
+## Rules
+
+- Run at isolate init, before any user code: capture any global you rely on
+  (e.g. `globalThis.Event`) eagerly so later monkey-patching can't break you.
+- No `import`/`export` — these are classic function bodies, not modules.
+- ESLint (`eslint.config.mjs` at the repo root, `npm run lint`) declares
+  `exports`, `module`, `binding` and the reachable native globals; `no-undef`
+  is the typo net. If a builtin starts using a new native global, add it there.
+- File names are kebab-case; the name determines the `BuiltinId` enum value
+  (`weak-ref.js` → `kWeakRef`) and the script origin. New files must also be
+  added to `RUNTIME_BUILTIN_JS` in `test-app/runtime/CMakeLists.txt` — the
+  build fails with an explicit message if that list drifts out of sync
+  (`js2c.mjs --check-dir`).
diff --git a/test-app/runtime/src/main/cpp/js/blob-url.js b/test-app/runtime/src/main/cpp/js/blob-url.js
new file mode 100644
index 000000000..0f0ce4fdd
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/blob-url.js
@@ -0,0 +1,59 @@
+const BLOB_STORE = new Map();
+URL.createObjectURL = function (object, options = null) {
+    try {
+        if (object instanceof Blob || object instanceof File) {
+            const id = java.util.UUID.randomUUID().toString();
+            const ret = `blob:nativescript/${id}`;
+            BLOB_STORE.set(ret, {
+                blob: object,
+                type: object?.type,
+                ext: options?.ext,
+            });
+            return ret;
+        }
+    } catch (error) {
+        return null;
+    }
+    return null;
+};
+URL.revokeObjectURL = function (url) {
+    BLOB_STORE.delete(url);
+};
+const InternalAccessor = class {};
+InternalAccessor.getData = function (url) {
+    return BLOB_STORE.get(url);
+};
+URL.InternalAccessor = InternalAccessor;
+Object.defineProperty(URL.prototype, 'searchParams', {
+    get() {
+        if (this._searchParams == null) {
+            this._searchParams = new URLSearchParams(this.search);
+            Object.defineProperty(this._searchParams, '_url', {
+                enumerable: false,
+                writable: false,
+                value: this,
+            });
+            this._searchParams._append = this._searchParams.append;
+            this._searchParams.append = function (name, value) {
+                this._append(name, value);
+                this._url.search = this.toString();
+            };
+            this._searchParams._delete = this._searchParams.delete;
+            this._searchParams.delete = function (name) {
+                this._delete(name);
+                this._url.search = this.toString();
+            };
+            this._searchParams._set = this._searchParams.set;
+            this._searchParams.set = function (name, value) {
+                this._set(name, value);
+                this._url.search = this.toString();
+            };
+            this._searchParams._sort = this._searchParams.sort;
+            this._searchParams.sort = function () {
+                this._sort();
+                this._url.search = this.toString();
+            };
+        }
+        return this._searchParams;
+    },
+});
diff --git a/test-app/runtime/src/main/cpp/js/error-events.js b/test-app/runtime/src/main/cpp/js/error-events.js
new file mode 100644
index 000000000..43b4e3f53
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/error-events.js
@@ -0,0 +1,90 @@
+"use strict";
+
+const { globalTarget, nativeReportFatal } = binding;
+var g = globalThis;
+var Event = g.Event;
+
+function ErrorEvent(type, opts) {
+  opts = opts || {};
+  Event.call(this, type, opts);
+  this.message = opts.message !== undefined ? String(opts.message) : "";
+  this.filename = opts.filename !== undefined ? String(opts.filename) : "";
+  this.lineno = opts.lineno !== undefined ? (opts.lineno | 0) : 0;
+  this.colno = opts.colno !== undefined ? (opts.colno | 0) : 0;
+  this.error = opts.error !== undefined ? opts.error : null;
+}
+ErrorEvent.prototype = Object.create(Event.prototype);
+ErrorEvent.prototype.constructor = ErrorEvent;
+
+function PromiseRejectionEvent(type, opts) {
+  opts = opts || {};
+  Event.call(this, type, opts);
+  this.promise = opts.promise;
+  this.reason = opts.reason;
+}
+PromiseRejectionEvent.prototype = Object.create(Event.prototype);
+PromiseRejectionEvent.prototype.constructor = PromiseRejectionEvent;
+
+// A listener that throws must not stop other listeners: route the thrown
+// value to the native fatal tail instead of ever recursively dispatching
+// another `error` event from inside dispatch.
+globalTarget._installListenerErrorReporter(function (e) {
+  try { nativeReportFatal(e, (e && e.stack) || ""); } catch (ignored) {}
+});
+
+g.reportError = function (e) {
+  if (arguments.length === 0) {
+    throw new TypeError("Failed to execute 'reportError': 1 argument required, but only 0 present.");
+  }
+  var ev = new ErrorEvent("error", {
+    message: (e && e.message !== undefined && e.message !== null) ? String(e.message) : String(e),
+    error: e,
+    cancelable: true
+  });
+  if (globalTarget.dispatchEvent(ev)) {
+    nativeReportFatal(e, (e && e.stack) || "");
+  }
+};
+
+g.ErrorEvent = ErrorEvent;
+g.PromiseRejectionEvent = PromiseRejectionEvent;
+
+// Closures called by C++. They never look up globalThis.dispatchEvent, so
+// they keep working even if app code overwrites it.
+function dispatchErrorEvent(error, message, stack) {
+  var ev = new ErrorEvent("error", {
+    message: message !== undefined && message !== null ? String(message) : "",
+    error: error,
+    cancelable: true
+  });
+  globalTarget.dispatchEvent(ev);
+  return ev.defaultPrevented;
+}
+function dispatchUnhandledRejection(promise, reason) {
+  var ev = new PromiseRejectionEvent("unhandledrejection", {
+    promise: promise,
+    reason: reason,
+    cancelable: true
+  });
+  globalTarget.dispatchEvent(ev);
+  return ev.defaultPrevented;
+}
+function dispatchRejectionHandled(promise, reason) {
+  var ev = new PromiseRejectionEvent("rejectionhandled", {
+    promise: promise,
+    reason: reason,
+    cancelable: false
+  });
+  globalTarget.dispatchEvent(ev);
+}
+function dispatchNativeUncaughtError(error, message, stack) {
+  var ev = new ErrorEvent("nativeuncaughterror", {
+    message: message !== undefined && message !== null ? String(message) : "",
+    error: error,
+    cancelable: true
+  });
+  globalTarget.dispatchEvent(ev);
+  return ev.defaultPrevented;
+}
+
+module.exports = [dispatchErrorEvent, dispatchUnhandledRejection, dispatchRejectionHandled, dispatchNativeUncaughtError];
diff --git a/test-app/runtime/src/main/cpp/js/events.js b/test-app/runtime/src/main/cpp/js/events.js
new file mode 100644
index 000000000..612f35701
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/events.js
@@ -0,0 +1,127 @@
+"use strict";
+var g = globalThis;
+
+function Event(type, opts) {
+  opts = opts || {};
+  this.type = String(type);
+  this.bubbles = !!opts.bubbles;
+  this.cancelable = !!opts.cancelable;
+  this.composed = !!opts.composed;
+  this.defaultPrevented = false;
+  this.target = null;
+  this.currentTarget = null;
+  this._stopPropagation = false;
+  this._stopImmediate = false;
+}
+Event.prototype.preventDefault = function () {
+  if (this.cancelable) { this.defaultPrevented = true; }
+};
+Event.prototype.stopPropagation = function () { this._stopPropagation = true; };
+Event.prototype.stopImmediatePropagation = function () {
+  this._stopPropagation = true;
+  this._stopImmediate = true;
+};
+
+// A listener that throws must not stop other listeners: route the thrown
+// value to the native fatal tail instead of ever recursively dispatching
+// another `error` event from inside dispatch. The error-events layer
+// installs the real reporter via _installListenerErrorReporter (before any
+// user code runs); until then a thrown listener is swallowed.
+var reportListenerError = function (e) {};
+
+function EventTargetImpl() { this._listeners = Object.create(null); }
+EventTargetImpl.prototype.addEventListener = function (type, callback, options) {
+  if (callback === null || callback === undefined) { return; }
+  type = String(type);
+  var capture = false, once = false;
+  if (typeof options === "boolean") {
+    capture = options;
+  } else if (options && typeof options === "object") {
+    capture = !!options.capture;
+    once = !!options.once;
+  }
+  var list = this._listeners[type];
+  if (!list) { list = this._listeners[type] = []; }
+  for (var i = 0; i < list.length; i++) {
+    if (list[i].callback === callback && list[i].capture === capture) { return; }
+  }
+  list.push({ callback: callback, once: once, capture: capture });
+};
+EventTargetImpl.prototype.removeEventListener = function (type, callback, options) {
+  type = String(type);
+  var capture = false;
+  if (typeof options === "boolean") {
+    capture = options;
+  } else if (options && typeof options === "object") {
+    capture = !!options.capture;
+  }
+  var list = this._listeners[type];
+  if (!list) { return; }
+  for (var i = 0; i < list.length; i++) {
+    if (list[i].callback === callback && list[i].capture === capture) {
+      list.splice(i, 1);
+      return;
+    }
+  }
+};
+EventTargetImpl.prototype.dispatchEvent = function (event) {
+  event.target = this;
+  event.currentTarget = this;
+  var list = this._listeners[event.type];
+  if (list) {
+    // Snapshot so listeners added during dispatch are not invoked and
+    // registration order is preserved.
+    var snapshot = list.slice();
+    for (var i = 0; i < snapshot.length; i++) {
+      var entry = snapshot[i];
+      var idx = list.indexOf(entry);
+      if (idx === -1) { continue; }  // removed since snapshot
+      if (entry.once) { list.splice(idx, 1); }
+      var cb = entry.callback;
+      try {
+        if (typeof cb === "function") {
+          cb.call(this, event);
+        } else if (cb && typeof cb.handleEvent === "function") {
+          cb.handleEvent(event);
+        }
+      } catch (e) {
+        reportListenerError(e);
+      }
+      if (event._stopImmediate) { break; }
+    }
+  }
+  event.currentTarget = null;
+  return !event.defaultPrevented;
+};
+
+// Internal EventTarget instance backing the global. globalThis's prototype
+// is intentionally NOT made an EventTarget; only the three methods are
+// bound onto it.
+var globalTarget = new EventTargetImpl();
+// Called by the error-events layer to install the native listener-error
+// reporter into this closure. One-shot: the backing target leaks to app
+// code via event.target, so the hook removes itself after the install
+// (which happens during runtime init, before any user code runs).
+globalTarget._installListenerErrorReporter = function (fn) {
+  reportListenerError = fn;
+  delete globalTarget._installListenerErrorReporter;
+};
+g.addEventListener = function (type, callback, options) {
+  return globalTarget.addEventListener(type, callback, options);
+};
+g.removeEventListener = function (type, callback, options) {
+  return globalTarget.removeEventListener(type, callback, options);
+};
+g.dispatchEvent = function (event) {
+  return globalTarget.dispatchEvent(event);
+};
+
+function EventTarget() { EventTargetImpl.call(this); }
+EventTarget.prototype.addEventListener = EventTargetImpl.prototype.addEventListener;
+EventTarget.prototype.removeEventListener = EventTargetImpl.prototype.removeEventListener;
+EventTarget.prototype.dispatchEvent = EventTargetImpl.prototype.dispatchEvent;
+
+g.Event = Event;
+g.EventTarget = EventTarget;
+
+module.exports = globalTarget;
diff --git a/test-app/runtime/src/main/cpp/js/json-helper.js b/test-app/runtime/src/main/cpp/js/json-helper.js
new file mode 100644
index 000000000..b082c2c1d
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/json-helper.js
@@ -0,0 +1,32 @@
+function serialize(data) {
+    let store;
+    switch (typeof data) {
+        case "string":
+        case "boolean":
+        case "number": {
+            return data;
+        }
+        case "object": {
+            if (!data) {
+                return null;
+            }
+
+            if (data instanceof Date) {
+                return data.toJSON();
+            }
+
+            if (Array.isArray(data)) {
+                store = new org.json.JSONArray();
+                data.forEach((item) => store.put(serialize(item)));
+                return store;
+            }
+
+            store = new org.json.JSONObject();
+            Object.keys(data).forEach((key) => store.put(key, serialize(data[key])));
+            return store;
+        }
+        default:
+            return null;
+    }
+}
+module.exports = serialize;
diff --git a/test-app/runtime/src/main/cpp/js/message-loop-timer.js b/test-app/runtime/src/main/cpp/js/message-loop-timer.js
new file mode 100644
index 000000000..44da362b5
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/message-loop-timer.js
@@ -0,0 +1,35 @@
+const { messageLoopTimerStart, messageLoopTimerStop } = binding;
+
+// We proxy the WebAssembly's compile, compileStreaming, instantiate and
+// instantiateStreaming methods so that they can start and stop a
+// MessageLoopTimer inside the promise callbacks. This timer will call
+// the v8::platform::PumpMessageLoop method at regular intervals.
+// https://github.com/NativeScript/android-runtime/issues/1558
+
+global.WebAssembly = new Proxy(WebAssembly, {
+    get: (target, name) => {
+        let origMethod = target[name];
+        let proxyMethods = [
+            "compile",
+            "compileStreaming",
+            "instantiate",
+            "instantiateStreaming"
+        ];
+
+        if (proxyMethods.indexOf(name) < 0) {
+            return origMethod;
+        }
+
+        return function (...args) {
+            messageLoopTimerStart();
+            let result = origMethod.apply(this, args);
+            return result.then(x => {
+                messageLoopTimerStop();
+                return x;
+            }).catch(e => {
+                messageLoopTimerStop();
+                throw e;
+            });
+        };
+    }
+});
diff --git a/test-app/runtime/src/main/cpp/js/require-factory.js b/test-app/runtime/src/main/cpp/js/require-factory.js
new file mode 100644
index 000000000..dc477af0a
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/require-factory.js
@@ -0,0 +1,12 @@
+function require_factory(requireInternal, dirName) {
+    return function require(modulePath) {
+        if (global.__requireOverride) {
+            var result = global.__requireOverride(modulePath, dirName);
+            if (result) {
+                return result;
+            }
+        }
+        return requireInternal(modulePath, dirName);
+    }
+}
+module.exports = require_factory;
diff --git a/test-app/runtime/src/main/cpp/js/smart-stringify.js b/test-app/runtime/src/main/cpp/js/smart-stringify.js
new file mode 100644
index 000000000..b7b06098f
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/smart-stringify.js
@@ -0,0 +1,17 @@
+function smartStringify(object) {
+    const seen = [];
+    var replacer = function (key, value) {
+        if (value != null && typeof value == "object") {
+            if (seen.indexOf(value) >= 0) {
+                if (key) {
+                    return "[Circular]";
+                }
+                return;
+            }
+            seen.push(value);
+        }
+        return value;
+    };
+    return JSON.stringify(object, replacer, 2);
+}
+module.exports = smartStringify;
diff --git a/test-app/runtime/src/main/cpp/js/weak-ref.js b/test-app/runtime/src/main/cpp/js/weak-ref.js
new file mode 100644
index 000000000..01e9fe035
--- /dev/null
+++ b/test-app/runtime/src/main/cpp/js/weak-ref.js
@@ -0,0 +1,9 @@
+global.WeakRef.prototype.get = global.WeakRef.prototype.deref;
+global.WeakRef.prototype.__hasWarnedAboutClear = false;
+global.WeakRef.prototype.clear = () => {
+    if(global.WeakRef.prototype.__hasWarnedAboutClear) {
+        return;
+    }
+    global.WeakRef.prototype.__hasWarnedAboutClear = true;
+    console.warn('WeakRef.clear() is non-standard and has been deprecated. It does nothing and the call can be safely removed.');
+}
diff --git a/tools/js2c.mjs b/tools/js2c.mjs
new file mode 100644
index 000000000..987b3bc31
--- /dev/null
+++ b/tools/js2c.mjs
@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+// Converts the runtime's builtin .js sources into a generated C++ table
+// (RuntimeBuiltins.h / RuntimeBuiltins.cpp) compiled into libNativeScript.so.
+// Invoked by a custom command in test-app/runtime/CMakeLists.txt.
+import { readFileSync, writeFileSync, renameSync, mkdirSync, existsSync, readdirSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { parseArgs } from 'node:util';
+
+const USAGE = `usage: node tools/js2c.mjs --out-dir <dir> [--minify] [--check-dir <dir>] <file.js>...
+
+Generates <dir>/RuntimeBuiltins.h and <dir>/RuntimeBuiltins.cpp from the given
+builtin JavaScript sources. Builtin ids and script-origin names derive from the
+file names (weak-ref.js -> BuiltinId::kWeakRef, "internal/weak-ref.js").
+
+options:
+  --out-dir <dir>        output directory for the generated files (required)
+  --minify               minify sources with esbuild (whitespace + syntax only)
+  --check-dir <dir>      directory whose .js files must exactly match the
+                         inputs; drift fails the build (CMake's incremental
+                         change detection reads the explicit input list, so a
+                         new builtin missing from it would otherwise be skipped
+                         silently on incremental builds)
+  --help                 show this message`;
+
+let args;
+try {
+  args = parseArgs({
+    options: {
+      'out-dir': { type: 'string' },
+      minify: { type: 'boolean', default: false },
+      'check-dir': { type: 'string' },
+      help: { type: 'boolean', default: false },
+    },
+    allowPositionals: true,
+  });
+} catch (e) {
+  console.error(e.message);
+  console.error(USAGE);
+  process.exit(1);
+}
+if (args.values.help) {
+  console.log(USAGE);
+  process.exit(0);
+}
+const outDir = args.values['out-dir'];
+const inputs = args.positionals;
+if (!outDir || inputs.length === 0) {
+  console.error('error: --out-dir and at least one input file are required');
+  console.error(USAGE);
+  process.exit(1);
+}
+
+// Stable ordering regardless of shell glob order, so output never churns.
+inputs.sort((a, b) => basename(a).localeCompare(basename(b)));
+
+if (args.values['check-dir']) {
+  const present = readdirSync(args.values['check-dir'])
+    .filter((f) => f.endsWith('.js'))
+    .sort();
+  const actual = inputs.map((f) => basename(f)).sort();
+  if (JSON.stringify(present) !== JSON.stringify(actual)) {
+    const missing = present.filter((f) => !actual.includes(f));
+    const stale = actual.filter((f) => !present.includes(f));
+    console.error(`error: the RUNTIME_BUILTIN_JS list in CMakeLists.txt is out of sync with ${args.values['check-dir']}`);
+    if (missing.length) console.error(`  add:    ${missing.join(', ')}`);
+    if (stale.length) console.error(`  remove: ${stale.join(', ')}`);
+    process.exit(1);
+  }
+}
+
+const builtins = [];
+for (const file of inputs) {
+  if (!existsSync(file)) {
+    console.error(`error: no such file: ${file}`);
+    process.exit(1);
+  }
+  if (!file.endsWith('.js')) {
+    console.error(`error: builtins must be .js function bodies, got: ${file}`);
+    process.exit(1);
+  }
+  const stem = basename(file).replace(/\.js$/, '');
+  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(stem)) {
+    console.error(`error: file name must be kebab-case .js: ${file}`);
+    process.exit(1);
+  }
+  let source = readFileSync(file, 'utf8');
+  if (args.values.minify) {
+    // Lazy import: esbuild is only needed when minification is requested.
+    const esbuild = await import('esbuild');
+    source = (await esbuild.transform(source, {
+      minifyWhitespace: true,
+      minifySyntax: true,
+      legalComments: 'none',
+    })).code;
+  }
+  const id = 'k' + stem.replace(/(^|-)([a-z0-9])/g, (_, __, c) => c.toUpperCase());
+  builtins.push({ stem, id, origin: `internal/${stem}.js`, source });
+}
+
+const ids = builtins.map((b) => `    ${b.id},`).join('\n');
+const header = `// generated by tools/js2c.mjs - do not edit
+#ifndef RUNTIMEBUILTINS_H_
+#define RUNTIMEBUILTINS_H_
+
+#include <cstddef>
+
+namespace tns {
+
+enum class BuiltinId : unsigned {
+${ids}
+    kCount,
+};
+
+struct BuiltinSource {
+    const char* name;    // script origin, e.g. "internal/weak-ref.js"
+    const char* source;  // NUL-terminated UTF-8
+    size_t length;       // bytes, excluding the NUL
+};
+
+const BuiltinSource& GetBuiltinSource(BuiltinId id);
+
+}  // namespace tns
+
+#endif /* RUNTIMEBUILTINS_H_ */
+`;
+
+// Byte arrays sidestep every C string-literal escaping pitfall.
+function toByteArray(name, text) {
+  const bytes = Buffer.from(text, 'utf8');
+  const lines = [];
+  for (let i = 0; i < bytes.length; i += 16) {
+    lines.push('        ' + [...bytes.subarray(i, i + 16)].map((b) => `0x${b.toString(16).padStart(2, '0')},`).join(' '));
+  }
+  // unsigned char: UTF-8 bytes >= 0x80 are narrowing errors in a char array.
+  return `static const unsigned char ${name}[] = {\n${lines.join('\n')}\n        0x00};\n`;
+}
+
+const arrays = builtins
+  .map((b) => `// ${b.stem}.js\n${toByteArray(`kSource${b.id.slice(1)}`, b.source)}`)
+  .join('\n');
+const entries = builtins
+  .map((b) => `        {"${b.origin}", reinterpret_cast<const char*>(kSource${b.id.slice(1)}), sizeof(kSource${b.id.slice(1)}) - 1},`)
+  .join('\n');
+const impl = `// generated by tools/js2c.mjs - do not edit
+#include "RuntimeBuiltins.h"
+
+namespace tns {
+
+namespace {
+
+${arrays}
+const BuiltinSource kBuiltins[] = {
+${entries}
+};
+
+}  // namespace
+
+const BuiltinSource& GetBuiltinSource(BuiltinId id) {
+    return kBuiltins[static_cast<unsigned>(id)];
+}
+
+}  // namespace tns
+`;
+
+mkdirSync(outDir, { recursive: true });
+// Gradle configures one CMake build per ABI and may run them concurrently
+// against this single shared output directory; write through a per-process
+// temp file so a concurrent reader never sees a truncated header.
+for (const [name, content] of [['RuntimeBuiltins.h', header], ['RuntimeBuiltins.cpp', impl]]) {
+  const path = join(outDir, name);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, content);
+  renameSync(tmp, path);
+}
+console.log(`js2c: generated ${builtins.length} builtins into ${outDir}`);