feat: add Node-style primordials to runtime builtins

The runtime's builtins install globals and leave closures behind that keep
running for the lifetime of the app: event dispatch, the Promise proxy traps,
console's smart-stringify, __extends. Those closures reached for intrinsics
(Array.prototype.slice, JSON.stringify, Object.create, ...) through the live
globals, so app code replacing one could break or observe runtime internals.

primordials.js captures the intrinsics the other builtins need into a frozen,
null-prototype namespace and BuiltinLoader passes it to every builtin as a
second fixed parameter next to `binding`. It is built lazily on the first
RunBuiltin of an isolate — during runtime init, before user code — and cached
in Caches, so workers snapshot their own realm and late-compiling builtins
still see pristine intrinsics.

Instance methods are uncurried Node-style, `uncurryThis(fn)` being
Function.prototype.bind.bind(Function.prototype.call): ArrayPrototypeSlice(list, 1)
rather than list.slice(1). Benchmarked under jitless (which is how the runtime
always runs on device) uncurried calls cost +5-12% per op over a raw method
call but beat the captured-and-.call() alternative, so they are used uniformly.

ESLint gains no-restricted-properties for the captured statics and
no-restricted-globals for the captured constructors, each pointing at the
replacement; uncurried instance-method use stays a review rule since the
receiver cannot be matched.

Author: edusperoni

NativeScript/runtime/BuiltinLoader.cpp

@@ -3,6 +3,7 @@
 #include <mutex>
 #include <vector>
 
+#include "Caches.h"
 #include "Helpers.h"
 
 using namespace v8;
@@ -15,10 +16,13 @@ namespace {
 std::mutex builtinCacheMutex;
 std::vector<uint8_t> builtinCache[static_cast<unsigned>(BuiltinId::kCount)];
 
-// Every builtin is compiled as a function body receiving this single, fixed
-// parameter (Node's internalBinding idiom): natives arrive as properties of
-// one bag object and each file destructures what it needs.
+// Every builtin is compiled as a function body receiving these two fixed
+// parameters: natives arrive as properties of the `binding` bag (Node's
+// internalBinding idiom) and intrinsics as properties of `primordials`; each
+// file destructures what it needs.
 constexpr const char* kBindingParamName = "binding";
+constexpr const char* kPrimordialsParamName = "primordials";
+constexpr int kParamCount = 2;
 
 MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
   Isolate* isolate = v8::Isolate::GetCurrent();
@@ -45,7 +49,9 @@ MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
   );
   Local<v8::String> sourceText = tns::ToV8String(
       isolate, builtin.source, static_cast<int>(builtin.length));
-  Local<v8::String> params[] = {tns::ToV8String(isolate, kBindingParamName)};
+  Local<v8::String> params[] = {
+      tns::ToV8String(isolate, kBindingParamName),
+      tns::ToV8String(isolate, kPrimordialsParamName)};
 
   Local<v8::Function> fn;
   if (!blob.empty()) {
@@ -55,7 +61,8 @@ MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
         blob.data(), static_cast<int>(blob.size()),
         ScriptCompiler::CachedData::BufferNotOwned);
     ScriptCompiler::Source source(sourceText, origin, cachedData);
-    if (ScriptCompiler::CompileFunction(context, &source, 1, params, 0, nullptr,
+    if (ScriptCompiler::CompileFunction(context, &source, kParamCount, params,
+                                        0, nullptr,
                                         ScriptCompiler::kConsumeCodeCache)
             .ToLocal(&fn) &&
         !cachedData->rejected) {
@@ -66,8 +73,8 @@ MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
   }
 
   ScriptCompiler::Source source(sourceText, origin);
-  if (!ScriptCompiler::CompileFunction(context, &source, 1, params, 0, nullptr,
-                                       ScriptCompiler::kEagerCompile)
+  if (!ScriptCompiler::CompileFunction(context, &source, kParamCount, params, 0,
+                                       nullptr, ScriptCompiler::kEagerCompile)
            .ToLocal(&fn)) {
     return MaybeLocal<v8::Function>();
   }
@@ -84,21 +91,57 @@ MaybeLocal<v8::Function> CompileBuiltin(Local<Context> context, BuiltinId id) {
   return fn;
 }
 
+MaybeLocal<Value> CallBuiltin(Local<Context> context, BuiltinId id,
+                              Local<Value> binding, Local<Value> primordials) {
+  Isolate* isolate = v8::Isolate::GetCurrent();
+
+  Local<v8::Function> fn;
+  if (!CompileBuiltin(context, id).ToLocal(&fn)) {
+    return MaybeLocal<Value>();
+  }
+
+  Local<Value> args[] = {
+      binding.IsEmpty() ? v8::Undefined(isolate).As<Value>() : binding,
+      primordials};
+  return fn->Call(context, v8::Undefined(isolate), kParamCount, args);
+}
+
+// Snapshot of the intrinsics, taken the first time any builtin runs in this
+// isolate — during runtime init, before user code can replace a global. Later
+// builtins (smart-stringify compiles lazily, on the first object logged) get
+// the same pristine snapshot.
+MaybeLocal<Object> GetPrimordials(Local<Context> context) {
+  Isolate* isolate = v8::Isolate::GetCurrent();
+  std::shared_ptr<Caches> cache = Caches::Get(isolate);
+  if (cache->Primordials != nullptr) {
+    return cache->Primordials->Get(isolate);
+  }
+
+  Local<Value> result;
+  if (!CallBuiltin(context, BuiltinId::kPrimordials, Local<Value>(),
+                   v8::Undefined(isolate))
+           .ToLocal(&result) ||
+      !result->IsObject()) {
+    return MaybeLocal<Object>();
+  }
+
+  Local<Object> primordials = result.As<Object>();
+  cache->Primordials =
+      std::make_unique<Persistent<Object>>(isolate, primordials);
+  return primordials;
+}
+
 }  // 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)) {
+  Local<Object> primordials;
+  if (!GetPrimordials(context).ToLocal(&primordials)) {
     return MaybeLocal<Value>();
   }
 
-  Local<Value> args[] = {binding.IsEmpty() ? v8::Undefined(isolate).As<Value>()
-                                           : binding};
-  return fn->Call(context, v8::Undefined(isolate), 1, args);
+  return CallBuiltin(context, id, binding, primordials);
 }
 
 }  // namespace tns

NativeScript/runtime/BuiltinLoader.h

@@ -8,10 +8,13 @@ namespace tns {
 
 class BuiltinLoader {
  public:
-  // Compiles the builtin identified by id as a function body with the single
-  // fixed parameter `binding` (Node's internalBinding idiom), calls it with
-  // the given bag of natives (or undefined when omitted), and returns its
-  // return value. Scripts carry an "internal/<name>.js" origin so runtime
+  // Compiles the builtin identified by id as a function body with the two
+  // fixed parameters `binding` (Node's internalBinding idiom) and
+  // `primordials`, calls it with the given bag of natives (or undefined when
+  // omitted) plus this isolate's frozen intrinsics snapshot, and returns its
+  // return value. The snapshot is produced by the kPrimordials builtin on
+  // first use and cached per isolate, so it is taken before any user code can
+  // replace a global. 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) consume it

NativeScript/runtime/Caches.h

@@ -163,6 +163,12 @@ class Caches {
   std::unique_ptr<v8::Persistent<v8::Function>> UnmanagedTypeCtorFunc =
       std::unique_ptr<v8::Persistent<v8::Function>>(nullptr);
 
+  // Frozen intrinsics snapshot returned by internal/primordials.js, passed to
+  // every builtin as its second fixed parameter (BuiltinLoader::RunBuiltin).
+  // Per isolate, so workers snapshot their own realm's intrinsics.
+  std::unique_ptr<v8::Persistent<v8::Object>> Primordials =
+      std::unique_ptr<v8::Persistent<v8::Object>>(nullptr);
+
   // Internal EventTarget instance backing the global, returned by the generic
   // event-primitives bootstrap IIFE (Events::Init). Holds the real listener
   // store, so native layers dispatch through it without going through

NativeScript/runtime/js/README.md

@@ -9,32 +9,66 @@ at runtime `BuiltinLoader::RunBuiltin` compiles and executes them with an
 ## Contract (Node's internalBinding idiom)
 
 Every file is compiled as a **function body** via `v8::ScriptCompiler::CompileFunction`
-with one fixed parameter:
+with two fixed parameters:
 
 ```js
 const { someNative, anotherNative } = binding;
+const { ArrayPrototypeSlice, ObjectCreate } = primordials;
 ```
 
 - `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.
+- `primordials` is the frozen intrinsics snapshot built by `primordials.js`
+  (see below), the same object for every builtin in an isolate.
 - Because the file is a function body, **top-level `return` is legal** — a
   builtin's return value is what `RunBuiltin` hands back to C++ (used to
   return factory functions and init results).
 - 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.
+- Destructure `binding` and `primordials` once, at the top of the file, so the
+  file's 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.
-  (Planned: a frozen `primordials` namespace as a second fixed parameter,
-  Node-style, to make this systematic for closures that outlive init.)
+  For intrinsics that is what `primordials` is; for everything else
+  (`URLSearchParams`, …) capture it into a file-level `const`.
 - No `import`/`export` — these are classic function bodies, not modules.
 - ESLint (`eslint.config.mjs` at the repo root, run by lint-staged) declares
-  `binding` and the reachable native globals; `no-undef` is the typo net.
-  If a builtin starts using a new native global, add it there.
+  `binding`, `primordials` and the reachable native globals; `no-undef` is the
+  typo net. If a builtin starts using a new native global, add it there.
+  `no-restricted-properties` fails the lint on direct use of the captured
+  statics (`JSON.stringify`, `Object.defineProperty`, …). Uncurried instance
+  methods can't be matched that way, so `list.slice()` instead of
+  `ArrayPrototypeSlice(list)` is caught by review, not by the linter.
 - File names are kebab-case; the name determines the `BuiltinId` enum value
   (`promise-proxy.js` → `kPromiseProxy`) and the script origin. New files must
   also be added to `tools/js2c-inputs.xcfilelist` — the build fails with an
   explicit message if that list drifts out of sync (`js2c.mjs --filelist`).
+
+## primordials
+
+`primordials.js` runs first in every isolate — lazily, on the first
+`RunBuiltin` call, which happens during runtime init — and its frozen,
+null-prototype return value is cached per isolate (`Caches::Primordials`) and
+handed to every other builtin. Builtins that compile late (`smart-stringify`
+is compiled on the first object logged) therefore still see intrinsics as they
+were before user code ran.
+
+Naming follows Node: statics keep their path (`JSONStringify`,
+`ObjectDefineProperty`), instance methods are **uncurried** so the receiver
+becomes the first argument:
+
+```js
+ArrayPrototypeSlice(list, 1)     // not list.slice(1)
+FunctionPrototypeCall(cb, this, event)  // not cb.call(this, event)
+```
+
+Uncurrying is `Function.prototype.bind.bind(Function.prototype.call)`, which on
+the jitless configuration the runtime ships is both faster than a captured
+`fn.call(...)` and immune to a replaced `Function.prototype.call`.
+
+Add only what a builtin actually needs; this is not a mirror of Node's list.
+Plain constructor calls made once at init time (`new Map()` while
+bootstrapping) may stay direct — the rule targets code in closures that
+outlive init.

NativeScript/runtime/js/blob-url.js

@@ -1,10 +1,25 @@
+const {
+    Map,
+    MapPrototypeDelete,
+    MapPrototypeGet,
+    MapPrototypeSet,
+    ObjectDefineProperty,
+    StringPrototypeToLowerCase,
+} = primordials;
+
+// The searchParams accessor below outlives init, so the constructor it reaches
+// for is captured now rather than looked up on the global at call time.
+const URLSearchParamsCtor = URLSearchParams;
+
 const BLOB_STORE = new Map();
 URL.createObjectURL = function (object, options = null) {
     try {
+        // Blob/File come from the app layer, not the runtime, so these stay
+        // live lookups; the catch below covers them not existing yet.
         if (object instanceof Blob || object instanceof File) {
-            const id = NSUUID.UUID().UUIDString.toLowerCase();
+            const id = StringPrototypeToLowerCase(NSUUID.UUID().UUIDString);
             const ret = `blob:nativescript/${id}`;
-            BLOB_STORE.set(ret, {
+            MapPrototypeSet(BLOB_STORE, ret, {
                 blob: object,
                 type: object?.type,
                 ext: options?.ext,
@@ -17,18 +32,18 @@ URL.createObjectURL = function (object, options = null) {
     return null;
 };
 URL.revokeObjectURL = function (url) {
-    BLOB_STORE.delete(url);
+    MapPrototypeDelete(BLOB_STORE, url);
 };
 const InternalAccessor = class {};
 InternalAccessor.getData = function (url) {
-    return BLOB_STORE.get(url);
+    return MapPrototypeGet(BLOB_STORE, url);
 };
 URL.InternalAccessor = InternalAccessor;
-Object.defineProperty(URL.prototype, 'searchParams', {
+ObjectDefineProperty(URL.prototype, 'searchParams', {
     get() {
         if (this._searchParams == null) {
-            this._searchParams = new URLSearchParams(this.search);
-            Object.defineProperty(this._searchParams, '_url', {
+            this._searchParams = new URLSearchParamsCtor(this.search);
+            ObjectDefineProperty(this._searchParams, '_url', {
                 enumerable: false,
                 writable: false,
                 value: this,

NativeScript/runtime/js/class-extends.js

@@ -1,11 +1,12 @@
-    function __extends(d, b) { 
+    const { ObjectCreate, ObjectPrototypeHasOwnProperty } = primordials;
+    function __extends(d, b) {
          for (var p in b) {
-             if (b.hasOwnProperty(p)) {
+             if (ObjectPrototypeHasOwnProperty(b, p)) {
                  d[p] = b[p];
              }
          }
          function __() { this.constructor = d; }
-         d.prototype = b === null ? Object.create(b) : 
+         d.prototype = b === null ? ObjectCreate(b) :
 (__.prototype = b.prototype, new __());
-    } 
+    }
     return __extends;

NativeScript/runtime/js/error-events.js

@@ -1,28 +1,29 @@
 "use strict";
 
 const { globalTarget, nativeReportFatal } = binding;
+const { FunctionPrototypeCall, ObjectCreate, String, TypeError } = primordials;
 var g = globalThis;
 var Event = g.Event;
 
 function ErrorEvent(type, opts) {
   opts = opts || {};
-  Event.call(this, type, opts);
+  FunctionPrototypeCall(Event, 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 = ObjectCreate(Event.prototype);
 ErrorEvent.prototype.constructor = ErrorEvent;
 
 function PromiseRejectionEvent(type, opts) {
   opts = opts || {};
-  Event.call(this, type, opts);
+  FunctionPrototypeCall(Event, this, type, opts);
   this.promise = opts.promise;
   this.reason = opts.reason;
 }
-PromiseRejectionEvent.prototype = Object.create(Event.prototype);
+PromiseRejectionEvent.prototype = ObjectCreate(Event.prototype);
 PromiseRejectionEvent.prototype.constructor = PromiseRejectionEvent;
 
 // A listener that throws must not stop other listeners: route the thrown