@nubjs/nub-linux-x64 0.0.12 → 0.0.14

package/runtime/transform-core.mjs

@@ -20,18 +20,119 @@
 // top-level hook registration here — importing this module never augments the
 // realm; the tier files do that.
 
-import module from "node:module";
-import { readFileSync, writeFileSync, mkdirSync, statSync, renameSync, unlinkSync, readdirSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { createRequire } from "node:module";
-import { createHash } from "node:crypto";
-import { join, dirname, resolve as pathResolve, extname as pathExtname } from "node:path";
-import { transformSync } from "oxc-transform";
-import { getTsconfig, createPathsMatcher } from "get-tsconfig";
-import { NUB_VERSION } from "./version.mjs";
-
+// EVERY dependency of this module is pulled in via CJS `require()` (below), NOT
+// via static ESM `import`. This is load-bearing for loader compatibility (R11):
+// nub loads transform-core through `require(esm)`, and Node's `require(esm)`
+// instantiates the module by walking its STATIC IMPORT graph through whatever ESM
+// loader hooks are registered — including the USER's `--loader`/`register()`
+// chain. Static `import oxc-transform`/`get-tsconfig`/`./version.mjs`/`node:*`
+// here therefore leaked nub's entire internal graph (transform-core, version.mjs,
+// oxc-transform, get-tsconfig, their transitive node_modules deps, and the node:
+// builtins) THROUGH the user's resolve/load hooks, which observed and corrupted
+// it (a user load hook returning `source: 1` for version.mjs, a resolve hook
+// appending `?foo` to `oxc-transform`, a strict loader throwing on the bare
+// `oxc-transform` specifier — see test-esm-loader-chaining, -example-loader,
+// -preserve-symlinks-not-found, test-shadow-realm-custom-loaders). Verified: a CJS
+// `require()` of a package/builtin does NOT route through the ESM loader chain, so
+// loading the graph this way bypasses the user chain entirely. `process
+// .getBuiltinModule` fetches node: builtins synchronously off the loader chain;
+// `createRequire(import.meta.url)` resolves the bare deps from nub's distribution.
+// This file keeps its `export`s (it stays an ES module), but has ZERO static
+// imports, so `require(esm)` finds no dependency graph to route through the user.
+const { createRequire } = process.getBuiltinModule("node:module");
 const __require = createRequire(import.meta.url);
 
+const module = process.getBuiltinModule("node:module");
+const { readFileSync, writeFileSync, mkdirSync, statSync, renameSync, unlinkSync, readdirSync } = process.getBuiltinModule("node:fs");
+const { fileURLToPath, pathToFileURL } = process.getBuiltinModule("node:url");
+const { join, dirname, resolve: pathResolve, extname: pathExtname } = process.getBuiltinModule("node:path");
+// oxc-transform is `type: module`, so a plain `require("oxc-transform")` uses
+// `require(esm)` and Node instantiates its ESM entry by walking ITS static
+// imports through the registered ESM loader chain — i.e. through the USER's
+// `--loader` worker (which nub's main-thread sync hooks do NOT chain into, so the
+// resolveSpec short-circuit can't catch it). oxc-transform's entry has exactly one
+// ESM-only construct that leaks: `import { createRequire } from 'node:module'`
+// (the rest is CJS `require`/`module.exports`-shaped). To keep it off the chain
+// entirely we load it AS CommonJS: read the entry source, neutralize its tiny ESM
+// header (the `import { createRequire }` line, the `const require =
+// createRequire(import.meta.url)` shadow, the `import.meta.url`-based `__dirname`)
+// and convert its `export { X }` footer to `module.exports`, then compile it with
+// `module._compile` at its real path so its internal `require('./binding.node')`
+// and `__dirname` resolve correctly. A CJS-compiled module has no static-import
+// graph for Node to route through any loader. Falls back to plain require(esm) if
+// the source shape ever changes (then the leak returns, but transpilation works).
+function requireOxcAsCjs() {
+  const Module = module;
+  let entry;
+  try {
+    entry = __require.resolve("oxc-transform");
+  } catch {
+    return __require("oxc-transform");
+  }
+  // Only the .js NAPI-RS wrapper has the mixed ESM-header/CJS-body shape we can
+  // safely transform; anything else, defer to the normal loader.
+  if (!entry.endsWith(".js")) return __require("oxc-transform");
+  try {
+    let src = readFileSync(entry, "utf8");
+    // Strip the ESM header: `import { createRequire } from 'node:module'`,
+    // `const require = createRequire(import.meta.url)`, and any
+    // `const __dirname = new URL('.', import.meta.url).pathname`. In a CJS module
+    // `require`, `__dirname`, `__filename` are already injected by _compile.
+    src = src
+      .replace(/^\s*import\s*\{[^}]*\}\s*from\s*['"]node:module['"];?\s*$/m, "")
+      .replace(/^\s*const\s+require\s*=\s*createRequire\([^)]*\);?\s*$/m, "")
+      .replace(/^\s*const\s+__dirname\s*=\s*new URL\([^)]*\)\.pathname;?\s*$/m, "");
+    // Convert the `export { Name }` footer lines to a single CJS exports block.
+    const names = [];
+    src = src.replace(/^\s*export\s*\{\s*([A-Za-z0-9_$]+)\s*\}\s*;?\s*$/gm, (_m, n) => {
+      names.push(n);
+      return "";
+    });
+    // Guard: if any `import`/`export`/`import.meta` survived, we don't understand
+    // this version's shape — bail to the safe loader rather than ship broken code.
+    if (/^\s*(import|export)\s/m.test(src) || /\bimport\.meta\b/.test(src)) {
+      return __require("oxc-transform");
+    }
+    if (names.length === 0) return __require("oxc-transform");
+    src += `\nmodule.exports = { ${names.join(", ")} };\n`;
+    const m = new Module(entry, null);
+    m.filename = entry;
+    m.paths = Module._nodeModulePaths(dirname(entry));
+    m._compile(src, entry);
+    return m.exports;
+  } catch {
+    return __require("oxc-transform");
+  }
+}
+const { transformSync } = requireOxcAsCjs();
+const { getTsconfig, createPathsMatcher } = __require("get-tsconfig");
+
+// NUB_VERSION is the single source of truth in runtime/version.mjs. We must NOT
+// `import` it (that would route version.mjs through the user loader chain — see
+// above; a user load hook returning bogus source corrupts it), and we cannot
+// `require()` it either (it is an ES module, so `require()` uses require(esm),
+// which re-routes version.mjs's own load through the chain). Instead read its
+// text directly and extract the literal — `make version` keeps the assignment on
+// one line (`export const NUB_VERSION = "x.y.z";`), so a tight regex is stable.
+const NUB_VERSION = (() => {
+  try {
+    const text = readFileSync(fileURLToPath(new URL("./version.mjs", import.meta.url)), "utf8");
+    const m = text.match(/NUB_VERSION\s*=\s*["']([^"']+)["']/);
+    if (m) return m[1];
+  } catch {}
+  return "0.0.0";
+})();
+
+// `node:crypto` is used ONLY to hash the transpile-cache key, so it loads lazily
+// on first transpile rather than at module top level. Importing it eagerly pulls
+// in the crypto/tls native tree (~dozens of builtins) on EVERY startup — including
+// a plain-JS run that never transpiles anything (R7). The first `.ts` transpile
+// pays the one-time require; a no-TS run never touches it. Memoized.
+let _createHash = null;
+function getCreateHash() {
+  return (_createHash ??= __require("node:crypto").createHash);
+}
+
 // ── Constants ───────────────────────────────────────────────────────
 export const TRANSPILE_EXTS = new Set([".ts", ".tsx", ".mts", ".cts", ".jsx"]);
 export const DATA_EXTS = { ".jsonc": "jsonc", ".json5": "json5", ".toml": "toml", ".yaml": "yaml", ".yml": "yaml", ".txt": "txt" };
@@ -263,10 +364,102 @@ export function getProbeOrder(parentExt) {
   }
 }
 
+// nub's own runtime directory (this file's dir, as a file: URL prefix). Any
+// resolution whose IMPORTER lives here is one of nub's internal requires — the
+// preload loading transform-core, transform-core requiring oxc, the Temporal lazy
+// getter resolving @js-temporal/polyfill — and must NEVER be routed through nub's
+// own clobber/vendored/tsconfig logic: those are user-code conveniences, and
+// applying them to nub's internals both breaks them (e.g. the Temporal clobber
+// re-exports globalThis.Temporal, which IS the getter → a require of the polyfill
+// from the getter would recurse into the clobber) and amplifies the user loader
+// chain by re-walking nub's internal graph through user hooks (R11). Short-circuit
+// to native resolution for these.
+const RUNTIME_DIR_URL = new URL(".", import.meta.url).href;
+
+// nub's internal-graph package roots — the file: URL prefixes of the npm packages
+// nub itself loads (oxc-transform, get-tsconfig) and their transitive deps. Any
+// resolution whose IMPORTER lives under one of these is part of nub's internal
+// graph, NOT user code. `oxc-transform` is `type: module`, so even when nub pulls
+// it in via CJS `require()`, Node loads its `index.js` through `require(esm)` and
+// walks ITS static `import "node:module"` graph through the registered ESM loader
+// chain — including the USER's loader. That re-leaks nub internals one hop down
+// (R11): test-esm-example-loader's strict loader throws on `node:module`,
+// loader-resolve-shortcircuit appends `?foo` to oxc's specifiers, etc. So a
+// nub-internal-graph resolution must FULLY short-circuit (resolve natively, return
+// shortCircuit:true) — never delegate to nextResolve — for EVERY specifier,
+// including node: builtins and the package's own relative imports. Computed lazily
+// (and pinned even on resolve failure) so a missing dep can't wedge startup.
+let _nubGraphRoots = null;
+function nubGraphRoots() {
+  if (_nubGraphRoots) return _nubGraphRoots;
+  const roots = [];
+  for (const pkg of ["oxc-transform", "get-tsconfig"]) {
+    try {
+      const entry = __require.resolve(pkg);
+      // Package root = the directory two levels up does not work generically;
+      // instead key on the package-name segment: everything under
+      // `.../node_modules/<pkg>/` is that package. Use the entry's dir-with-pkg.
+      const idx = entry.lastIndexOf(`${sep()}node_modules${sep()}`);
+      if (idx !== -1) {
+        // Keep through the package-name segment (handles scoped names too).
+        const afterNM = entry.slice(idx + (`${sep()}node_modules${sep()}`).length);
+        const firstSeg = afterNM.startsWith("@")
+          ? afterNM.split(sep()).slice(0, 2).join(sep())
+          : afterNM.split(sep())[0];
+        const pkgRoot = entry.slice(0, idx) + `${sep()}node_modules${sep()}` + firstSeg + sep();
+        roots.push(pathToFileURL(pkgRoot).href);
+      }
+    } catch {}
+  }
+  return (_nubGraphRoots = roots);
+}
+function sep() {
+  return process.platform === "win32" ? "\\" : "/";
+}
+
+// Is this importer part of nub's own internal module graph (runtime dir or a nub
+// dependency package)? Such imports must bypass the user ESM loader chain entirely.
+function isNubInternalParent(parentURL) {
+  if (!parentURL) return false;
+  const p = String(parentURL);
+  if (p.startsWith(RUNTIME_DIR_URL)) return true;
+  for (const root of nubGraphRoots()) {
+    if (p.startsWith(root)) return true;
+  }
+  return false;
+}
+
 // Resolve a specifier the way both hook tiers do. Returns `{ url, shortCircuit }`
 // to short-circuit Node's resolver, or `null` to fall through to `nextResolve`.
 // `parentURL` is the importer (a file: URL string), or "" for the entry.
 export function resolveSpec(specifier, parentURL) {
+  // nub's own internal graph (importer inside nub's runtime dir OR a nub
+  // dependency package): resolve natively and SHORT-CIRCUIT so nextResolve (the
+  // user's loader chain) never observes nub's internals. This MUST run before the
+  // node:/data:/builtin early-returns below, because those `return null` =
+  // DELEGATE to the user loader — and a nub-internal `import "node:module"` (e.g.
+  // from oxc-transform's ESM entry) delegated to a strict user loader is exactly
+  // the R11 leak. See isNubInternalParent / nubGraphRoots.
+  if (isNubInternalParent(parentURL)) {
+    if (specifier.startsWith("node:") || module.builtinModules.includes(specifier)) {
+      const url = specifier.startsWith("node:") ? specifier : `node:${specifier}`;
+      return { url, shortCircuit: true };
+    }
+    if (specifier.startsWith("data:")) return { url: specifier, shortCircuit: true };
+    // A relative/bare import from inside nub's graph: resolve it natively from the
+    // parent's own require() resolver (NOT nub's tsconfig/clobber/probe logic) and
+    // short-circuit. Bare specifiers resolve from the parent package's location.
+    try {
+      const parentReq = createRequire(parentURL);
+      const resolved = parentReq.resolve(specifier);
+      return { url: pathToFileURL(resolved).href, shortCircuit: true };
+    } catch {
+      // Couldn't resolve from the parent (e.g. a non-file: parent): still short-
+      // circuit by handing the specifier back as-is, so the user chain is bypassed.
+      return null;
+    }
+  }
+
   // node: and data: protocols, and bare Node built-ins, are never ours.
   if (specifier.startsWith("node:") || specifier.startsWith("data:")) return null;
   if (module.builtinModules.includes(specifier)) return null;
@@ -544,7 +737,7 @@ if (!CACHE_DISABLED) {
 }
 
 function cacheKey(source) {
-  return createHash("sha256")
+  return getCreateHash()("sha256")
     .update(NUB_VERSION).update("\0")
     .update(CACHE_SCHEMA).update("\0")
     .update(source)
@@ -557,7 +750,7 @@ function cacheKey(source) {
 // garbage to V8.
 const CACHE_INTEGRITY_LEN = 16;
 function cacheIntegrity(body) {
-  return createHash("sha256").update(body).digest("hex").slice(0, CACHE_INTEGRITY_LEN);
+  return getCreateHash()("sha256").update(body).digest("hex").slice(0, CACHE_INTEGRITY_LEN);
 }
 function cacheGet(key) {
   if (!cacheDir) return null;
@@ -695,6 +888,14 @@ export function loadTranspile(url, ext) {
     map.sourcesContent = [source];
     code += `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}\n`;
   }
+  // Append a `//# sourceURL=` magic comment, matching Node's native strip-types
+  // (lib/internal/modules/typescript.js: `return ${code}\n\n//# sourceURL=${filename}`).
+  // This is the marker V8/the inspector reads to set `scriptParsed.hasSourceURL =
+  // true` — the signal that a script is generated/transpiled rather than read
+  // verbatim from disk (test-inspector-strip-types asserts it). It coexists with
+  // the inline sourceMappingURL above (maps still drive stack frames); sourceURL
+  // only names the origin. Use the absolute file path, exactly as Node does.
+  code += `\n//# sourceURL=${filePath}\n`;
 
   // Store the chosen format as a leading byte so cache hits skip re-detection.
   cacheSet(key, (format === "commonjs" ? "c" : "m") + code);

package/runtime/version.mjs

@@ -9,4 +9,4 @@
 // previously lived as a literal inside preload.mjs, which `make version` patched,
 // while the worker carried a hand-maintained "…-compat" copy that `make version`
 // never touched — a latent staleness bug this module closes.)
-export const NUB_VERSION = "0.0.12";
+export const NUB_VERSION = "0.0.14";

package/runtime/worker-polyfill.mjs

@@ -2,28 +2,52 @@
 // Wraps node:worker_threads.Worker with EventTarget inheritance,
 // real MessageEvent/ErrorEvent, and URL-only constructor (Deno shape).
 
-import { Worker as NodeWorker, parentPort, isMainThread } from "node:worker_threads";
-import { fileURLToPath } from "node:url";
+// node: builtins are fetched via `process.getBuiltinModule` rather than static
+// `import`. This file is loaded via `require(esm)` from the preload, and Node's
+// `require(esm)` instantiates an ES module by walking its STATIC IMPORT graph
+// through whatever ESM loader chain is registered — including the USER's
+// `--loader`/`register()` hooks. A static `import { Worker } from
+// "node:worker_threads"` therefore routes the builtin through the user chain; a
+// user load hook that returns SOURCE for node:worker_threads makes V8 see no
+// `Worker` export, so `new NodeWorker(...)` references an undefined binding and
+// the child crashes (observed against test-esm-loader-chaining). `process
+// .getBuiltinModule` fetches the real builtin synchronously off the loader
+// graph, bypassing the user chain entirely — same fix transform-core.mjs uses.
+const { Worker: NodeWorker, parentPort, isMainThread } = process.getBuiltinModule("node:worker_threads");
+const { fileURLToPath } = process.getBuiltinModule("node:url");
 
 // `ErrorEvent` only became a global in Node 26. On the 22/24 floor it is
 // undefined, so `new ErrorEvent(...)` below would throw a ReferenceError inside
 // the worker's "error" handler — crashing the PARENT thread on every worker
-// that throws. Resolve the constructor once at load: use the native global when
-// present, otherwise a minimal Event subclass carrying the standard ErrorEvent
-// fields (message/error/filename/lineno/colno). See wiki/research/worker-polyfill.md.
-const ErrorEventCtor =
-  typeof globalThis.ErrorEvent === "function"
-    ? globalThis.ErrorEvent
-    : class ErrorEvent extends Event {
-        constructor(type, init = {}) {
-          super(type, init);
-          this.message = init.message ?? "";
-          this.error = init.error ?? null;
-          this.filename = init.filename ?? "";
-          this.lineno = init.lineno ?? 0;
-          this.colno = init.colno ?? 0;
-        }
-      };
+// that throws. Resolve the constructor lazily and memoize on first use: use the
+// native global when present, otherwise a minimal Event subclass carrying the
+// standard ErrorEvent fields (message/error/filename/lineno/colno).
+// See wiki/research/worker-polyfill.md.
+//
+// LAZY (not resolved at module load) on purpose: reading `globalThis.ErrorEvent`
+// at top level trips Node's lazy `ErrorEvent` getter, which eagerly realizes
+// ~100+ builtins (http2/tls/crypto/zlib/perf_hooks/webstreams) on EVERY startup
+// — a cold-start regression (process.moduleLoadList ~230 vs node's ~110) that
+// contradicts nub's fast-runner premise for the common "run a plain file, never
+// touch Workers" case. The constructors are only ever needed inside the
+// post-construction error/message handlers, so deferring resolution there costs
+// nothing for non-Worker programs and nothing measurable for Worker ones.
+let _ErrorEventCtor;
+function getErrorEventCtor() {
+  return (_ErrorEventCtor ??=
+    typeof globalThis.ErrorEvent === "function"
+      ? globalThis.ErrorEvent
+      : class ErrorEvent extends Event {
+          constructor(type, init = {}) {
+            super(type, init);
+            this.message = init.message ?? "";
+            this.error = init.error ?? null;
+            this.filename = init.filename ?? "";
+            this.lineno = init.lineno ?? 0;
+            this.colno = init.colno ?? 0;
+          }
+        });
+}
 
 if (typeof globalThis.Worker === "undefined") {
   class Worker extends EventTarget {
@@ -66,6 +90,7 @@ if (typeof globalThis.Worker === "undefined") {
       });
 
       this.#worker.on("error", (err) => {
+        const ErrorEventCtor = getErrorEventCtor();
         this.dispatchEvent(new ErrorEventCtor("error", { error: err, message: err.message }));
       });
 
@@ -107,7 +132,16 @@ if (typeof globalThis.Worker === "undefined") {
     }
   }
 
-  globalThis.Worker = Worker;
+  // NON-ENUMERABLE: invisible to `Object.keys(globalThis)` / for-in is the
+  // additive contract — vanilla-Node code that enumerates the global object must
+  // not observe nub's injected `Worker`. Node defines its own globals the same
+  // way. Writable+configurable so user code can still override it.
+  Object.defineProperty(globalThis, "Worker", {
+    value: Worker,
+    enumerable: false,
+    writable: true,
+    configurable: true,
+  });
 }
 
 // Worker-side bootstrap: emulate the DedicatedWorkerGlobalScope on top of
@@ -118,7 +152,22 @@ if (typeof globalThis.Worker === "undefined") {
 // and a parent→worker round-trip hangs — see wiki/research/worker-polyfill.md.
 if (!isMainThread && parentPort) {
   const scope = globalThis;
-  scope.self = scope;
+  // All of nub's worker-scope global injections below (self, addEventListener,
+  // removeEventListener, dispatchEvent, postMessage, close) are defined
+  // NON-ENUMERABLE. Node's worker global is not an EventTarget and exposes none
+  // of these, so a worker doing `Object.keys(globalThis)` / for-in must not see
+  // nub's additions — invisibility-to-enumeration is the additive contract.
+  // writable+configurable mirrors Node's own global descriptors. (`onmessage`/
+  // `onmessageerror` below already use Object.defineProperty, whose enumerable
+  // defaults to false.)
+  const defineGlobal = (name, value) =>
+    Object.defineProperty(scope, name, {
+      value,
+      enumerable: false,
+      writable: true,
+      configurable: true,
+    });
+  defineGlobal("self", scope);
 
   // `message`/`messageerror` are DELEGATED straight onto the native `parentPort`
   // (a real Node MessagePort) so Node's own C++ event-loop ref-counting governs
@@ -191,15 +240,15 @@ if (!isMainThread && parentPort) {
     }
   }
 
-  scope.addEventListener = (type, listener, opts) =>
+  defineGlobal("addEventListener", (type, listener, opts) =>
     DELEGATED.has(type)
       ? addDelegated(type, listener, opts)
-      : otherAdd(type, listener, opts);
-  scope.removeEventListener = (type, listener, opts) =>
+      : otherAdd(type, listener, opts));
+  defineGlobal("removeEventListener", (type, listener, opts) =>
     DELEGATED.has(type)
       ? removeDelegated(type, listener)
-      : otherRemove(type, listener, opts);
-  scope.dispatchEvent = (ev) => otherDispatch(ev);
+      : otherRemove(type, listener, opts));
+  defineGlobal("dispatchEvent", (ev) => otherDispatch(ev));
 
   // `onmessage` / `onmessageerror` register via the delegating add/remove above,
   // mirroring the web API and the main-side Worker. Assigning `null` removes the
@@ -221,9 +270,9 @@ if (!isMainThread && parentPort) {
 
   // Outbound + lifecycle.
   if (typeof scope.postMessage !== "function") {
-    scope.postMessage = (data, transfer) => parentPort.postMessage(data, transfer);
+    defineGlobal("postMessage", (data, transfer) => parentPort.postMessage(data, transfer));
   }
   if (typeof scope.close !== "function") {
-    scope.close = () => process.exit(0);
+    defineGlobal("close", () => process.exit(0));
   }
 }

package/runtime/polyfills.mjs

@@ -1,136 +0,0 @@
-// Polyfill preloads for Nub v0.1. All feature-detect and bow out
-// if the global is already present. Loaded via the main preload.
-//
-// Node 22.15+ (our floor) already has: navigator, navigator.locks,
-// navigator.hardwareConcurrency, WebSocket. No polyfills needed.
-//
-// Node 24+ adds: URLPattern, RegExp.escape, Error.isError, Promise.try.
-// We polyfill those on Node 22.x only.
-//
-// No Node version ships: Temporal, reportError, browser-shape Worker.
-// These need polyfills on all supported versions.
-
-// ── reportError (WinterTC min-common-API, not in any Node) ──────────
-if (typeof globalThis.reportError !== "function") {
-  globalThis.reportError = (err) => {
-    queueMicrotask(() => {
-      throw err;
-    });
-  };
-}
-
-// ── URLPattern (native on Node 24+, missing on 22.x) ───────────────
-if (typeof globalThis.URLPattern === "undefined") {
-  const mod = globalThis.__nubPreloaded?.urlpattern;
-  const URLPattern = mod?.URLPattern;
-  if (URLPattern) globalThis.URLPattern = URLPattern;
-}
-
-// Temporal (in no Node version) is installed as a LAZY global by the main
-// preload after this module runs — see preload.mjs (A37). Touching
-// globalThis.Temporal here would defeat that laziness, so we must not.
-
-// ── Stage 4 polyfills (native on Node 24+, missing on 22.x) ────────
-
-// RegExp.escape — spec-faithful port of the TC39 proposal (native on Node 24+),
-// so the 22.x floor behaves byte-for-byte like native: a leading digit/letter is
-// control-escaped, syntax chars are backslashed, control chars use \t\n\v\f\r, and
-// the "other punctuators" + whitespace set is hex-escaped. Verified byte-identical
-// to Node's native RegExp.escape across every ASCII char + leading/whitespace/
-// astral cases (so a concatenated `escape(s)` is safe too, not just
-// `new RegExp(escape(s))`). The earlier reduced-fidelity version only escaped the
-// syntax chars.
-if (typeof RegExp.escape !== "function") {
-  const SYNTAX = new Set(["^", "$", "\\", ".", "*", "+", "?", "(", ")", "[", "]", "{", "}", "|", "/"]);
-  const CONTROL = { "\t": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
-  // ASCII "other punctuators" the spec escapes by code, plus SPACE.
-  const OTHER = new Set([..." ,-=<>#&!%:;@~'\"`"]);
-  const isWhiteSpace = (cp) =>
-    cp === 0x09 || cp === 0x0a || cp === 0x0b || cp === 0x0c || cp === 0x0d ||
-    cp === 0x20 || cp === 0xa0 || cp === 0x1680 || (cp >= 0x2000 && cp <= 0x200a) ||
-    cp === 0x2028 || cp === 0x2029 || cp === 0x202f || cp === 0x205f || cp === 0x3000 ||
-    cp === 0xfeff;
-  const hexEscape = (cp) => {
-    if (cp <= 0xff) return "\\x" + cp.toString(16).padStart(2, "0");
-    if (cp <= 0xffff) return "\\u" + cp.toString(16).padStart(4, "0");
-    const h = cp - 0x10000;
-    const hi = 0xd800 + (h >> 10);
-    const lo = 0xdc00 + (h & 0x3ff);
-    return "\\u" + hi.toString(16).padStart(4, "0") + "\\u" + lo.toString(16).padStart(4, "0");
-  };
-  const encode = (ch, cp) =>
-    SYNTAX.has(ch)
-      ? "\\" + ch
-      : CONTROL[ch] ?? ((OTHER.has(ch) || isWhiteSpace(cp)) ? hexEscape(cp) : ch);
-  RegExp.escape = (s) => {
-    if (typeof s !== "string") throw new TypeError("RegExp.escape argument must be a string");
-    const cps = [...s]; // iterate by code point (astral-safe)
-    let out = "";
-    for (let i = 0; i < cps.length; i++) {
-      const ch = cps[i];
-      const cp = ch.codePointAt(0);
-      // A leading decimal-digit/ASCII-letter is control-escaped so a preceding `\`
-      // in a concatenated pattern can't form an escape sequence.
-      if (i === 0 && ((cp >= 0x30 && cp <= 0x39) || (cp >= 0x41 && cp <= 0x5a) || (cp >= 0x61 && cp <= 0x7a))) {
-        out += "\\x" + cp.toString(16).padStart(2, "0");
-      } else {
-        out += encode(ch, cp);
-      }
-    }
-    return out;
-  };
-}
-
-// Error.isError (~95% fidelity — cross-realm internal-slot unreachable)
-if (typeof Error.isError !== "function") {
-  Error.isError = (value) => {
-    if (value == null || typeof value !== "object") return false;
-    return value instanceof Error;
-  };
-}
-
-// Promise.try
-if (typeof Promise.try !== "function") {
-  Promise.try = (fn, ...args) => {
-    return new Promise((resolve) => resolve(fn(...args)));
-  };
-}
-
-// Float16Array (TC39 Stage 4, native on Node 24+; absent on our 22.x floor).
-// Installed from the spec-compliant @petamoriken/float16 polyfill (vendored,
-// preloaded by preload.mjs). It provides the full TypedArray method surface
-// (map/filter/subarray/set/reduce/…) and correct round-to-nearest-even,
-// including subnormals — unlike the prior hand-rolled Proxy shim, which had
-// ~30 methods missing and truncating/denormal-flushing conversion.
-//
-// INHERENT userland limitation (not fixable by any JS polyfill): a polyfilled
-// Float16Array isn't recognized by `ArrayBuffer.isView()` (it has no V8 internal
-// [[TypedArrayName]] slot). Code needing that check should use the polyfill's
-// `isFloat16Array`. See wiki/runtime/float16array-polyfill.md.
-if (typeof globalThis.Float16Array === "undefined") {
-  const f16 = globalThis.__nubPreloaded?.float16;
-  if (f16?.Float16Array) {
-    globalThis.Float16Array = f16.Float16Array;
-
-    if (typeof DataView.prototype.getFloat16 !== "function") {
-      DataView.prototype.getFloat16 = function (offset, littleEndian) {
-        return f16.getFloat16(this, offset, littleEndian);
-      };
-      DataView.prototype.setFloat16 = function (offset, value, littleEndian) {
-        f16.setFloat16(this, offset, value, littleEndian);
-      };
-    }
-
-    if (typeof Math.f16round !== "function") {
-      Math.f16round = f16.f16round;
-    }
-  }
-}
-
-// ── navigator.locks (native on Node 24+, missing on 22.x) ──────────
-if (typeof globalThis.navigator?.locks === "undefined") {
-  await import("./navigator-locks.mjs");
-}
-
-// ── Worker (browser-shape global, not in any Node) ──────────────────
-await import("./worker-polyfill.mjs");