@nubjs/nub-darwin-x64 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nubjs/nub-darwin-x64",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Nub binary for darwin-x64",
   "license": "MIT",
   "repository": "https://github.com/nubjs/nub",
@@ -11,7 +11,6 @@
     "x64"
   ],
   "files": [
-    "bin",
-    "runtime"
+    "bin"
   ]
 }

package/runtime/cache-evict.mjs

@@ -1,69 +0,0 @@
-// Bounded-size eviction for the transpile cache (A16). Kept in its own module
-// so it loads lazily — only when a sweep is actually due (see preload.mjs's
-// throttled maybeSweepCache) — and so it can be tested in isolation.
-//
-// LRU by mtime: when the cache exceeds `maxBytes`, delete oldest-written entries
-// until at or below `lowWater`. Entries are content-addressed, so evicting one
-// only costs a re-transpile on next use. mtime reflects write time, not last
-// read — true read-LRU would need an mtime touch on every cache hit, defeating
-// the read-only fast path; oldest-written is the right, cheap proxy for a cache
-// whose entries are written once per source version.
-
-import { readdirSync, statSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-
-// A valid cache entry is a 64-char lowercase-hex sha256 (see cacheKey in
-// preload.mjs). Everything else — the `.sweep` sentinel, `*.tmp` in-flight
-// writes from cacheSet — is skipped: never counted toward the cap, never
-// evicted.
-const ENTRY_RE = /^[0-9a-f]{64}$/;
-
-/**
- * Evict oldest entries from `dir` until total entry bytes ≤ `lowWater`, if they
- * exceed `maxBytes`. Returns `{ scanned, deleted, freed }`. Best-effort: a stat
- * or unlink that fails (concurrent reader/evictor, Windows open handle) is
- * skipped, and the next sweep retries. Never throws.
- */
-export function sweepCache(dir, maxBytes, lowWater = Math.floor(maxBytes * 0.75)) {
-  let names;
-  try {
-    names = readdirSync(dir);
-  } catch {
-    return { scanned: 0, deleted: 0, freed: 0 };
-  }
-
-  const entries = [];
-  let total = 0;
-  for (const name of names) {
-    if (!ENTRY_RE.test(name)) continue;
-    const path = join(dir, name);
-    const s = statSync(path, { throwIfNoEntry: false });
-    if (!s || !s.isFile()) continue;
-    entries.push({ path, size: s.size, mtime: s.mtimeMs });
-    total += s.size;
-  }
-
-  if (total <= maxBytes) {
-    return { scanned: entries.length, deleted: 0, freed: 0 };
-  }
-
-  // Oldest first; delete down to the low-water mark so we don't sweep again on
-  // the very next write.
-  entries.sort((a, b) => a.mtime - b.mtime);
-  let deleted = 0;
-  let freed = 0;
-  for (const e of entries) {
-    if (total <= lowWater) break;
-    try {
-      unlinkSync(e.path);
-      total -= e.size;
-      freed += e.size;
-      deleted++;
-    } catch {
-      // Already removed by a concurrent sweep, or held open (Windows): skip.
-      // `total` is unchanged so we keep trying to reach lowWater via other
-      // entries; the loop is bounded by `entries`, so it still terminates.
-    }
-  }
-  return { scanned: entries.length, deleted, freed };
-}

package/runtime/compile-cache-restore.mjs

@@ -1,21 +0,0 @@
-// R8 early step for the compat tier (--import preload.mjs). Restores
-// NODE_COMPILE_CACHE into process.env as a SIDE EFFECT, and must be the FIRST
-// import in preload.mjs so it runs before transform-core.mjs's module body — which
-// reads `NODE_COMPILE_CACHE === "0"` as nub's transpile-cache disable signal.
-//
-// Why a separate module instead of a statement in preload.mjs: ESM `import`s are
-// hoisted and their module bodies evaluate in source order BEFORE any statement in
-// the importer. transform-core.mjs is imported in preload.mjs, so the only way to
-// mutate process.env ahead of transform-core's evaluation is from a module imported
-// earlier in source order. The fast tier (preload.cjs, CommonJS) has no such
-// hoisting and calls common.restoreCompileCacheEnv() directly instead.
-//
-// spawn.rs strips NODE_COMPILE_CACHE from the child env (so Node's V8 compile cache
-// never caches nub's preload chain) and stashes the original value in a PID-keyed
-// sentinel file; here we read + delete it and put it back. Restoring it in JS does
-// not re-enable Node's bootstrap compile cache. See preload-common.cjs
-// (restoreCompileCacheEnv) for the full mechanism — this file just calls it.
-import { createRequire } from "node:module";
-
-const require_ = createRequire(import.meta.url);
-require_("./preload-common.cjs").restoreCompileCacheEnv();

package/runtime/floor-builtin.mjs

@@ -1,57 +0,0 @@
-// Compat-tier floor bootstrap: threads `node:module`'s `createRequire` into the
-// modules that fetch their `node:` builtins via `process.getBuiltinModule`
-// (transform-core.mjs, worker-polyfill.mjs) on the narrow FLOOR where that API is
-// absent — WITHOUT any globalThis surface.
-//
-// WHY those modules can't fetch the builtin themselves: both are loaded on the fast
-// tier via Node's `require(esm)`, which instantiates an ES module by walking its
-// STATIC IMPORT graph through whatever ESM loader chain is registered — including the
-// USER's `--experimental-loader` / `module.register` hooks. A static `import {
-// createRequire } from "node:module"` in either file therefore routed the builtin
-// through the user chain, and a user resolve/load hook that rejects or rewrites
-// `node:module` exploded nub's own load (observed against es-module/test-esm-example-
-// loader and the loader-chaining corpus). So they fetch builtins via
-// `process.getBuiltinModule` (synchronous, OFF the loader chain, no static import).
-//
-// `process.getBuiltinModule` only exists from Node 22.3 / 20.16 / 18.20.4. On the
-// narrow FLOOR below that (18.19.x, 20.11–20.15, 22.0–22.2) it is `undefined`, so the
-// floor needs another way to reach `node:module`'s `createRequire`. This file is that
-// fallback: it holds the LONE static `import { createRequire } from "node:module"`
-// and hands the value to transform-core / worker-polyfill through their module-scoped
-// SETTERS (no globalThis surface — a `globalThis.__nub*` sentinel is the same brand
-// leak as a NUB_* env var, enumerable in user code AND worker realms, so it is
-// forbidden; this threading honors the same enumeration-invisibility contract every
-// other nub polyfill keeps).
-//
-// WHY THIS IS LEAK-SAFE WHERE the static import in transform-core/worker-polyfill WAS
-// NOT: this module is imported ONLY by the compat-tier entries (preload.mjs and
-// preload-async-hooks.mjs), AHEAD of transform-core/worker-polyfill in their source
-// order. The FAST tier (preload.cjs) loads those via `require(esm)` directly and never
-// touches preload.mjs / preload-async-hooks.mjs — so this file's static `node:module`
-// import never enters the fast-tier `require(esm)` graph, and the user loader chain
-// can never observe it. On the compat tier the loader hooks run in nub's OWN worker
-// (preload-async-hooks) or on the main thread before any user `--loader` could
-// intercept a bare `node:` builtin, both off the user chain — so the static import is
-// harmless exactly where it's reachable.
-//
-// IMPORT ORDERING (load-bearing): the compat entries import this file BEFORE
-// transform-core/worker-polyfill, but ES modules evaluate the importEE before the
-// importer's body — so transform-core's body has ALREADY run by the time the setter
-// calls below fire (during THIS module's evaluation). That is fine: transform-core
-// acquires its floor builtins lazily and `setBootstrapCreateRequire` triggers that
-// acquisition immediately, so every binding is ready before the entry body and long
-// before any hook fires. On Node WITH getBuiltinModule this file is a near no-op (the
-// setters are called but those modules never consult `_bootstrapCreateRequire`).
-import { createRequire } from "node:module";
-import { setBootstrapCreateRequire as setTransformCoreCreateRequire } from "./transform-core.mjs";
-
-// The floor's `createRequire`, exported so the compat entries (and any future floor
-// consumer) can thread it elsewhere without re-importing `node:module` into their own
-// static graph.
-export { createRequire };
-
-// Thread it into transform-core unconditionally (the setter no-ops the floor branch
-// on Node WITH getBuiltinModule). worker-polyfill's setter is wired by the entries
-// themselves, AFTER they import worker-polyfill, since worker-polyfill is loaded later
-// in the entry's flow (via dynamic import) than this static import runs.
-setTransformCoreCreateRequire(createRequire);

package/runtime/navigator-locks.mjs

@@ -1,242 +0,0 @@
-// Web Locks API polyfill for Node < 24.5 (native on Node 24.5+, #58666).
-// Single-process only — locks don't coordinate across worker threads (a deliberate
-// scope: the common in-process serialization use is covered; cross-thread coordination
-// would need a SharedArrayBuffer waitlist and is out of scope until there's demand).
-//
-// Spec: https://w3c.github.io/web-locks/. Modeled to match Node's own
-// internal/locks.js (the native impl on 24.5+) so behavior is identical across the
-// version boundary — including `steal`, AbortSignal integration, and the option/name
-// validation that the WPT web-locks suite exercises. Requires a `navigator` object to
-// host `navigator.locks`; navigator-shim.mjs backfills that on Node < 21 and MUST run
-// first.
-
-if (typeof globalThis.navigator === "object" && typeof globalThis.navigator.locks === "undefined") {
-  const AbortSig = globalThis.AbortSignal;
-
-  const abortError = (msg) => new DOMException(msg || "The operation was aborted", "AbortError");
-  const stolenError = () => abortError("The lock was stolen by another request");
-  const notSupported = (msg) => new DOMException(msg, "NotSupportedError");
-
-  class Lock {
-    #name;
-    #mode;
-    constructor(name, mode) {
-      this.#name = name;
-      this.#mode = mode;
-    }
-    get name() { return this.#name; }
-    get mode() { return this.#mode; }
-  }
-
-  // held: name → { mode, holders:Set<Holder> }. A shared grant has N holders sharing
-  // one record; an exclusive grant has exactly one. queue: name → Array<Waiter> (FIFO).
-  const held = new Map();
-  const queue = new Map();
-
-  function canAcquire(name, mode) {
-    const rec = held.get(name);
-    if (!rec) return true;
-    return mode === "shared" && rec.mode === "shared";
-  }
-
-  // A FRESH request may be granted immediately only when no waiters are already
-  // queued for the name — otherwise it must queue behind them. This is the
-  // reader/writer FAIRNESS rule: a new shared request must NOT barge ahead of a
-  // pending exclusive request and join the current shared holders, which would
-  // starve the writer (WPT mode-mixed "An exclusive lock between shared locks").
-  // drainQueue, which only ever grants from the FRONT of the queue, keeps using
-  // canAcquire directly.
-  function canGrantNow(name, mode) {
-    const q = queue.get(name);
-    if (q && q.length > 0) return false;
-    return canAcquire(name, mode);
-  }
-
-  function addHolder(name, mode, holder) {
-    const rec = held.get(name);
-    if (rec) rec.holders.add(holder);
-    else held.set(name, { mode, holders: new Set([holder]) });
-  }
-
-  function removeHolder(name, holder) {
-    const rec = held.get(name);
-    if (!rec) return;
-    rec.holders.delete(holder);
-    if (rec.holders.size === 0) held.delete(name);
-  }
-
-  function enqueue(name, waiter) {
-    let q = queue.get(name);
-    if (!q) queue.set(name, (q = []));
-    q.push(waiter);
-  }
-
-  // Grant as many head-of-queue waiters as the current held state allows: a head
-  // exclusive takes the lock alone; a run of head shared waiters is all granted.
-  function drainQueue(name) {
-    const q = queue.get(name);
-    if (!q || q.length === 0) return;
-    while (q.length > 0) {
-      const first = q[0];
-      if (!canAcquire(name, first.mode)) break;
-      q.shift();
-      first.grant(); // synchronously addHolders, so canAcquire reflects it next iter
-      if (first.mode === "exclusive") break;
-    }
-    if (q.length === 0) queue.delete(name);
-  }
-
-  // Run `cb(lock)` as a holder of (name, mode); return the promise that settles when
-  // the holder releases (cb's result/throw) — or rejects early if a steal BREAKS it.
-  // The callback is invoked one microtask later (matching Node), so a synchronously
-  // signaled abort is observed before the callback runs.
-  function runHolder(name, mode, cb) {
-    const lock = new Lock(name, mode);
-    let broken = false;
-    let rejectReleased;
-    const holder = {
-      mode,
-      break(reason) {
-        if (broken) return;
-        broken = true;
-        // Remove WITHOUT draining — the stealer takes the lock next; queued waiters
-        // stay pending until the steal's own holder releases.
-        removeHolder(name, holder);
-        rejectReleased(reason);
-      },
-    };
-    addHolder(name, mode, holder);
-    return new Promise((resolve, reject) => {
-      rejectReleased = reject;
-      Promise.resolve()
-        .then(() => cb(lock))
-        .then(
-          (value) => { if (!broken) { removeHolder(name, holder); resolve(value); drainQueue(name); } },
-          (err) => { if (!broken) { removeHolder(name, holder); reject(err); drainQueue(name); } },
-        );
-    });
-  }
-
-  // The lock engine: returns the `released` promise. `cb` receives the granted Lock
-  // (or null on an ifAvailable miss). Mirrors the grant/steal/ifAvailable/queue shape
-  // of Node's internalBinding('locks').request.
-  function engineRequest(name, mode, steal, ifAvailable, cb) {
-    if (steal) {
-      const rec = held.get(name);
-      if (rec) for (const h of [...rec.holders]) h.break(stolenError());
-      return runHolder(name, "exclusive", cb);
-    }
-    if (canGrantNow(name, mode)) {
-      return runHolder(name, mode, cb);
-    }
-    if (ifAvailable) {
-      return Promise.resolve().then(() => cb(null));
-    }
-    return new Promise((resolve, reject) => {
-      const waiter = {
-        mode,
-        settled: false,
-        grant() {
-          if (waiter.settled) return;
-          waiter.settled = true;
-          runHolder(name, mode, cb).then(resolve, reject);
-        },
-      };
-      enqueue(name, waiter);
-    });
-  }
-
-  class LockManager {
-    async request(name, optionsOrCallback, maybeCallback) {
-      let options = optionsOrCallback;
-      let callback = maybeCallback;
-      if (callback === undefined) {
-        callback = options;
-        options = undefined;
-      }
-
-      // WebIDL DOMString coercion (throws TypeError on a Symbol, like the binding).
-      name = `${name}`;
-      if (typeof callback !== "function") {
-        throw new TypeError("Failed to execute 'request' on 'LockManager': parameter 2 is not a function.");
-      }
-      if (options === undefined || typeof options === "function") options = {};
-
-      const mode = options.mode === undefined ? "exclusive" : options.mode;
-      if (mode !== "exclusive" && mode !== "shared") {
-        throw new TypeError(`Failed to execute 'request' on 'LockManager': '${mode}' is not a valid value for enumeration LockMode.`);
-      }
-      const ifAvailable = !!options.ifAvailable;
-      const steal = !!options.steal;
-      const signal = options.signal;
-      if (signal !== undefined && signal !== null && !(AbortSig && signal instanceof AbortSig)) {
-        throw new TypeError("Failed to execute 'request' on 'LockManager': member signal is not of type AbortSignal.");
-      }
-
-      // Already-aborted signal rejects with its reason BEFORE the option-combo checks
-      // (matching Node's signal.throwIfAborted() ordering).
-      if (signal && signal.aborted) {
-        throw signal.reason || abortError();
-      }
-      if (name[0] === "-") {
-        throw notSupported("Lock name may not start with hyphen '-'");
-      }
-      if (ifAvailable && steal) {
-        throw notSupported("ifAvailable and steal options cannot be used together");
-      }
-      if (mode !== "exclusive" && steal) {
-        throw notSupported("mode must be 'exclusive' when using the steal option");
-      }
-      if (signal && (steal || ifAvailable)) {
-        throw notSupported("signal cannot be used with the steal or ifAvailable options");
-      }
-
-      // Signal path: the callback is deferred and skipped if the signal aborts before
-      // it runs; the abort rejects the OUTER promise iff the callback hasn't entered
-      // (lockGranted false). Verbatim shape of Node's internal/locks.js so a queued
-      // abort releases the slot (callback skipped) and the next waiter is granted.
-      if (signal) {
-        return new Promise((resolve, reject) => {
-          let lockGranted = false;
-          const onAbort = () => {
-            if (!lockGranted) reject(signal.reason || abortError());
-          };
-          signal.addEventListener("abort", onAbort, { once: true });
-          const wrapped = (lock) =>
-            Promise.resolve().then(() => {
-              if (signal.aborted) return undefined;
-              lockGranted = true;
-              return callback(lock);
-            });
-          const released = engineRequest(name, mode, false, false, wrapped);
-          released.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-        });
-      }
-
-      return engineRequest(name, mode, steal, ifAvailable, (lock) => callback(lock));
-    }
-
-    async query() {
-      // clientId is per-realm and opaque: `node-<pid>-0` (single-process; this polyfill
-      // does not coordinate across worker threads, so the threadId slot is always 0 —
-      // and we avoid importing node:worker_threads to keep this module builtin-free for a
-      // cheap bootstrap). The cross-context distinct-id WPT cases are browser-specific.
-      const clientId = `node-${process.pid}-0`;
-      const heldOut = [];
-      for (const [name, rec] of held) {
-        for (let i = 0; i < rec.holders.size; i++) heldOut.push({ name, mode: rec.mode, clientId });
-      }
-      const pending = [];
-      for (const [name, q] of queue) {
-        for (const w of q) if (!w.settled) pending.push({ name, mode: w.mode, clientId });
-      }
-      return { held: heldOut, pending };
-    }
-  }
-
-  Object.defineProperty(globalThis.navigator, "locks", {
-    value: new LockManager(),
-    enumerable: true,
-    configurable: true,
-  });
-}

package/runtime/navigator-shim.mjs

@@ -1,144 +0,0 @@
-// `navigator` global backfill for Node < 21 (where the global is wholly absent).
-//
-// Node ships `globalThis.navigator` from 21.0.0. Below that it is `undefined`, so
-// any web-platform API hosted ON navigator — chiefly `navigator.locks` (Web Locks,
-// see navigator-locks.mjs) — has no object to attach to and silently does nothing.
-// nub's floor is 18.19, so to make those APIs reach the floor we synthesize the
-// `navigator` object Node 21+ would provide. Companion to navigator-locks.mjs:
-// this MUST run BEFORE it so locks has a host on 18.19–20.x.
-//
-// Shape mirrors Node's internal/navigator.js: a `Navigator` instance with the
-// enumerable prototype getters `hardwareConcurrency`, `language`, `languages`,
-// `userAgent`, `platform` (locks is added separately by navigator-locks.mjs). The
-// userAgent is `Node.js/<major>` — NEVER `Nub/…`: the user is running Node, nub is
-// the augmenter, and a `Nub/` UA would be a brand-boundary leak.
-//
-// VERSION-GATE, not a global read: installNavigatorShim() returns early on Node >= 21
-// from `process.versions.node` WITHOUT ever touching `globalThis.navigator`. That
-// matters because on Node 24.5+ the native `navigator` is a lazy getter whose first
-// access realizes ~30 internal/stream/worker-io builtins — a cold-start regression
-// (test-bootstrap-modules). The shim must never trigger that; the version check makes
-// the fast tier (>= 22.15, navigator always present) a free no-op.
-//
-// node: builtins (node:os) are fetched via `process.getBuiltinModule` when present,
-// else via a createRequire THREADED IN through `setBootstrapCreateRequire` — the same
-// brand-safe, off-the-user-loader-chain pattern worker-polyfill.mjs uses. The narrow
-// floor (18.19.x, 20.11–20.15) lacks `process.getBuiltinModule`, and the shim only
-// touches os lazily (the `hardwareConcurrency` getter), so the threaded require is
-// needed exactly there. `os` is never loaded on Node >= 21 (the early return).
-
-let _bootstrapCreateRequire = null;
-export function setBootstrapCreateRequire(fn) {
-  _bootstrapCreateRequire = fn;
-}
-
-function __getBuiltin(id) {
-  if (typeof process.getBuiltinModule === "function") return process.getBuiltinModule(id);
-  if (_bootstrapCreateRequire) return _bootstrapCreateRequire(import.meta.url)(id);
-  // Last-resort: a bare specifier require off this module's own createRequire is
-  // unavailable in ESM without node:module, which is exactly what the threading
-  // avoids importing statically. If neither path is wired, surface a clear error.
-  throw new Error("navigator-shim: no builtin accessor for " + id);
-}
-
-function deriveLanguage() {
-  // Approximate Node's ICU default locale from the POSIX locale env, falling back
-  // to "en-US" (Node's own fallback). `en_US.UTF-8` → `en-US`.
-  const raw =
-    process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || "";
-  const base = raw.split(".")[0].split("@")[0].replace("_", "-");
-  return base && base !== "C" && base !== "POSIX" ? base : "en-US";
-}
-
-function navigatorPlatform(platform, arch) {
-  // Mirror node/lib/internal/navigator.js getNavigatorPlatform.
-  if (platform === "darwin") return "MacIntel";
-  if (platform === "win32") return "Win32";
-  if (platform === "linux") {
-    if (arch === "ia32") return "Linux i686";
-    if (arch === "x64") return "Linux x86_64";
-    return `Linux ${arch}`;
-  }
-  if (platform === "freebsd") return arch === "ia32" ? "FreeBSD i386" : arch === "x64" ? "FreeBSD amd64" : `FreeBSD ${arch}`;
-  if (platform === "openbsd") return arch === "ia32" ? "OpenBSD i386" : arch === "x64" ? "OpenBSD amd64" : `OpenBSD ${arch}`;
-  if (platform === "sunos") return arch === "ia32" ? "SunOS i86pc" : `SunOS ${arch}`;
-  if (platform === "aix") return "AIX";
-  return `${platform[0].toUpperCase()}${platform.slice(1)} ${arch}`;
-}
-
-// Build the Navigator class lazily (only when actually backfilling) so loading this
-// module on the fast tier costs nothing beyond the early-return check.
-function makeNavigator() {
-  let _hw, _lang, _langs, _ua, _plat;
-  class Navigator {
-    get hardwareConcurrency() {
-      // os.availableParallelism honors cgroup CPU limits (Node 18.14+/19.4+; present
-      // on the 18.19 floor); fall back to cpus().length on the off chance it's absent.
-      if (_hw === undefined) {
-        const os = __getBuiltin("node:os");
-        _hw = typeof os.availableParallelism === "function" ? os.availableParallelism() : os.cpus().length;
-      }
-      return _hw;
-    }
-    get language() {
-      return (_lang ??= deriveLanguage());
-    }
-    get languages() {
-      return (_langs ??= Object.freeze([this.language]));
-    }
-    get userAgent() {
-      // `Node.js/<major>` — match Node exactly; never a nub-branded UA.
-      return (_ua ??= `Node.js/${process.versions.node.split(".")[0]}`);
-    }
-    get platform() {
-      return (_plat ??= navigatorPlatform(process.platform, process.arch));
-    }
-  }
-  // Match Node's instance shape: the property getters live on the prototype and are
-  // ENUMERABLE (Node sets them with kEnumerableProperty), so `for (const k in
-  // navigator)` walks them while `Object.keys(navigator)` (own enumerable) is empty.
-  // Class-body getters default to enumerable:false, so flip them in place.
-  for (const k of ["hardwareConcurrency", "language", "languages", "userAgent", "platform"]) {
-    Object.defineProperty(Navigator.prototype, k, { enumerable: true });
-  }
-  return { Navigator, instance: new Navigator() };
-}
-
-// Install the navigator backfill if and only if the running Node lacks the global
-// (i.e. Node < 21). Idempotent and side-effect-free on Node >= 21.
-export function installNavigatorShim() {
-  const major = parseInt(process.versions.node.split(".")[0], 10);
-  // Node 21+ ships navigator natively — never read the (possibly lazy) global here.
-  if (major >= 21) return;
-  // Defensive idempotency for the < 21 path (navigator is genuinely undefined there,
-  // so this read can't trigger a lazy realization).
-  if (typeof globalThis.navigator !== "undefined") return;
-
-  const { Navigator, instance } = makeNavigator();
-
-  // The binding on globalThis is NON-ENUMERABLE (invisible to Object.keys(globalThis)
-  // / for-in) — nub's additive-global contract, matching how reportError and Worker
-  // are installed. Configurable + writable so user code may still override it.
-  Object.defineProperty(globalThis, "navigator", {
-    value: instance,
-    enumerable: false,
-    writable: true,
-    configurable: true,
-  });
-  // Node also exposes the `Navigator` constructor globally; mirror it (non-enumerable).
-  if (typeof globalThis.Navigator === "undefined") {
-    Object.defineProperty(globalThis, "Navigator", {
-      value: Navigator,
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    });
-  }
-}
-
-// Fast tier / modern compat (getBuiltinModule present, Node >= 20.16): install eagerly
-// at module eval — a guaranteed no-op above Node 21 thanks to the version gate, and
-// correct on a 20.16–20.x compat run where navigator is still absent. On the narrow
-// floor below getBuiltinModule the compat entry calls setBootstrapCreateRequire(...)
-// + installNavigatorShim() explicitly (mirroring worker-polyfill's wiring).
-if (typeof process.getBuiltinModule === "function") installNavigatorShim();