@nubjs/nub-win32-x64 0.0.12 → 0.0.13

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@nubjs/nub-win32-x64",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "description": "Nub binary for win32-x64",
   "license": "MIT",
-  "repository": "https://github.com/colinhacks/nub",
+  "repository": "https://github.com/nub-js/nub",
   "os": [
     "win32"
   ],

package/runtime/compile-cache-restore.mjs

@@ -0,0 +1,21 @@
+// 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/preload.mjs

@@ -1,317 +1,101 @@
-// Nub fast-path preload — Node 22.15+ (sync `module.registerHooks`).
+// Nub compat-tier preload — Node 18.19–22.14, injected via `--import` (ESM).
 //
-// This file is the main-thread `--import` preload for ALL tiers. It owns only
-// the tier-specific wiring; every resolution + transpile primitive lives in
-// runtime/transform-core.mjs (shared verbatim with the compat-tier loader
-// worker, so the two can never drift). What stays here:
-//   - watch-mode dependency IPC (main-thread only),
-//   - the thin resolve/load hooks that delegate to the core,
-//   - the main-thread CommonJS `require()` shim (Module._resolveFilename +
-//     require.extensions), installed on BOTH tiers — `module.register` hooks ESM
-//     but not require, and `module.registerHooks`' require coverage is incomplete
-//     before ~Node 24 (e.g. require-from-`.cts` on 22.15),
-//   - clobbered-polyfill preloading + the Temporal lazy global,
-//   - tier dispatch (registerHooks vs register).
-
+// The FAST tier (Node 22.15+) is loaded separately, as a `--require` CommonJS
+// preload (runtime/preload.cjs), so Node keeps its synchronous `Module.runMain`
+// CJS entry path (top-level `executionAsyncId()===1`, sync exception origin,
+// `require.main.id` `'.'`, `module.parent` `null`). The mere presence of an
+// `--import` ESM preload forces eager ESM-loader init that routes even a CJS entry
+// through the async ESM module-job (R1) — so the fast tier must NOT use `--import`.
+//
+// THIS file stays the compat path: on 18.19–22.14, `module.registerHooks` does not
+// exist and `require(esm)` is unreliable, so hooks run async in a dedicated loader
+// worker via `module.register`, and the parser is preloaded via dynamic `import()`
+// while we can still `await`. That async machinery is exactly why the compat tier
+// keeps `--import` — its top-level `await` is accepted here (an `--import` ESM
+// module may be async), and the < 22.15 floor has no equivalent sync surface.
+//
+// Resolution + transpile primitives come from runtime/transform-core.mjs; the
+// non-tier-specific wiring (watch IPC, the CJS require() shim, clobbered-polyfill
+// preloading, the Temporal lazy global) is shared verbatim with the fast tier via
+// runtime/preload-common.cjs, so the two tiers can never drift.
+
+// MUST be first: restores NODE_COMPILE_CACHE into process.env (R8) before
+// transform-core.mjs's body evaluates, since transform-core reads it as the
+// transpile-cache disable signal. ESM imports evaluate in source order, so this
+// side-effecting import has to precede the transform-core import. See
+// compile-cache-restore.mjs.
+import "./compile-cache-restore.mjs";
 import module from "node:module";
-import { readdirSync } from "node:fs";
-import { fileURLToPath, pathToFileURL } from "node:url";
 import { createRequire } from "node:module";
-import { join, dirname, resolve as pathResolve, extname as pathExtname } from "node:path";
-import {
-  TRANSPILE_EXTS, DATA_EXTS, TS_PARENT_EXTS,
-  extname, isNodeModules, getTsconfigForDir, getPackageType,
-  resolveSpec, resolveCjsPath, requireTargetIsEsm, loadTranspile, loadData,
-  maybeSweepCache, setWatchHooks, ensureParser,
-} from "./transform-core.mjs";
+import * as core from "./transform-core.mjs";
 
 const __require = createRequire(import.meta.url);
-
-// ── Watch-mode dependency reporting ─────────────────────────────────
-// Under `nub watch`, Node's FilesWatcher only watches files in the import graph;
-// config files (tsconfig.json, package.json) and `.env*` are NOT in any graph,
-// so an edit to them otherwise goes stale. Node accepts incremental
-// `process.send({'watch:require': [...]})` over its WATCH_REPORT_DEPENDENCIES
-// IPC at ANY point in the child's life (it adds each path to the watch set), so
-// we report config paths AS the core loader discovers them. The reporters are
-// injected into the core via setWatchHooks (below) so getTsconfigForDir /
-// getPackageType self-report. The flush is coalesced via setImmediate.
-const WATCH_REPORTING = process.env.WATCH_REPORT_DEPENDENCIES === "1" && typeof process.send === "function";
-const watchReported = new Set();
-const watchPending = [];
-let watchFlushScheduled = false;
-function flushWatchDeps() {
-  watchFlushScheduled = false;
-  if (watchPending.length === 0) return;
-  const batch = watchPending.splice(0, watchPending.length);
-  try { process.send({ "watch:require": batch }); } catch {}
-}
-function reportWatchDep(path) {
-  if (!WATCH_REPORTING || !path || watchReported.has(path)) return;
-  watchReported.add(path);
-  watchPending.push(path);
-  if (!watchFlushScheduled) {
-    watchFlushScheduled = true;
-    // A scheduled immediate is drained before the loop would exit, so even a
-    // script that finishes synchronously flushes its deps. (Don't unref: an
-    // unref'd immediate is skipped on a synchronous exit, dropping the report.)
-    setImmediate(flushWatchDeps);
-  }
-}
-// Report a directory's `.env*` files (the natural watch targets). Scanned once
-// per directory, lazily.
-const watchEnvScannedDirs = new Set();
-function reportEnvFilesIn(dir) {
-  if (!WATCH_REPORTING || watchEnvScannedDirs.has(dir)) return;
-  watchEnvScannedDirs.add(dir);
-  let entries;
-  try { entries = readdirSync(dir); } catch { return; }
-  for (const name of entries) {
-    if (name === ".env" || name.startsWith(".env.")) reportWatchDep(join(dir, name));
-  }
-}
-setWatchHooks({ reportDep: reportWatchDep, reportEnvDir: reportEnvFilesIn });
-
-// Best-effort bounded-cache eviction (main thread only; the core guards on it).
-maybeSweepCache();
-
-// ── Resolve hook ────────────────────────────────────────────────────
-function resolve(specifier, context, nextResolve) {
-  const r = resolveSpec(specifier, context.parentURL);
-  return r ?? nextResolve(specifier, context);
-}
-
-// ── Load hook ───────────────────────────────────────────────────────
-function load(url, context, nextLoad) {
-  const ext = extname(url);
-
-  // Watch mode: surface this file's nearest config files (tsconfig.json,
-  // package.json) + sibling `.env*` so edits to them restart the run. Done for
-  // every user file (not just transpiled ones) — getTsconfigForDir/getPackageType
-  // self-report via the injected watch hooks.
-  if (WATCH_REPORTING && url.startsWith("file:") && !isNodeModules(url)) {
-    try {
-      const dir = dirname(fileURLToPath(url));
-      getTsconfigForDir(dir);
-      getPackageType(dir);
-    } catch {}
-  }
-
-  if (TRANSPILE_EXTS.has(ext)) return loadTranspile(url, ext);
-  if (ext in DATA_EXTS) return loadData(url, ext);
-
-  return nextLoad(url, context);
-}
-
-// ── CommonJS require() augmentation (BOTH tiers) ────────────────────
-// `module.registerHooks`' CJS-`require()` coverage is INCOMPLETE before ~Node 24:
-// on Node 22.15 a `require()` from a `.cts` parent (which Node loads via the ESM
-// translator's special-require) hits native Module._resolveFilename with no
-// tsconfig/extensionless handling — a `require('@alias')` or `require('./x')` of a
-// `.ts` target throws MODULE_NOT_FOUND, while the same code works on Node 26 (where
-// registerHooks does cover it) and on the fast `import` path. On the compat tier
-// (18.19–22.14) the only hook surface is `module.register`, which intercepts the
-// ESM loader ONLY — so `require()` is entirely unaugmented there. Both gaps have
-// the same closure: install this main-thread CJS shim, reusing the core's canonical
-// resolveCjsPath / loadTranspile (no drift). It tries nub's resolution first and
-// FALLS THROUGH to native on a miss, so it is a safe no-op on the versions where
-// registerHooks already covers require (Node 24+/26). Mechanism stays within the
-// augmenter rules: exactly what `--require`-installing the ts-node / tsx CJS shim
-// has always done. So it runs on the fast tier too — registerHooks is necessary
-// but, below ~Node 24, not sufficient for require().
-// This error is surfaced ONLY on Node versions without native require(esm)
-// (< 20.19 / 22.0–22.11), where require() of an ES module genuinely cannot work.
-// On every require(esm)-capable Node, Node loads the ES module itself and this is
-// never reached. The message is user-facing: no internal mechanism names.
-function requireEsmError(filename) {
-  const err = new Error(
-    `Cannot require() this file — it is an ES module.\n` +
-    `  ${filename}\n` +
-    `It uses \`import\`/\`export\`, so it loads as an ES module, and this version of ` +
-    `Node can't require() an ES module. Load it with \`import(...)\` instead, rename ` +
-    `it to .cts for a CommonJS module, or upgrade Node.`,
-  );
-  err.code = "ERR_REQUIRE_ESM";
-  return err;
-}
-
-// `withClassicTranspile` — also install the `require.extensions` (classic CommonJS
-// loader) transpile hook. This is needed ONLY on Node WITHOUT native require(esm)
-// (< 20.19 / 22.0–22.11): there, `module.register`'s ESM-loader hooks can't reach a
-// `require()`, AND an ES module simply can't be require()d, so we transpile CJS
-// content classically and surface a clean error for ESM content. On require(esm)-
-// capable Node we DON'T install it — registering `require.extensions['.ts']` would
-// shadow Node's own native require(esm) of ES-module `.ts` files (breaking
-// `require("./esm.ts")`), and the resolve shim below plus the tier's load hook
-// already cover resolution + transpile.
-function installCjsRequireHooks(withClassicTranspile) {
-  // Module._resolveFilename: try nub's resolution first (tsconfig paths,
-  // extensionless .ts, .js→.ts). If the target is an ES-module TS file AND this
-  // Node can't require(esm), throw a clean error HERE — before Node's special-
-  // require (used for require() from a CJS module loaded via the ESM translator)
-  // crashes with an opaque `cjsCache.get(...)` TypeError. On require(esm)-capable
-  // Node, return the path and let Node load the ES module itself. On miss/own
-  // error, fall through to Node (augmentation never masks Node's diagnostics).
-  const origResolveFilename = module._resolveFilename;
-  module._resolveFilename = function (request, parent, isMain, options) {
-    let resolved = null;
-    try {
-      const parentPath = parent && typeof parent.filename === "string" ? parent.filename : null;
-      resolved = resolveCjsPath(request, parentPath);
-    } catch { /* fall through to Node */ }
-    if (resolved) {
-      if (withClassicTranspile && requireTargetIsEsm(resolved, pathExtname(resolved))) {
-        throw requireEsmError(resolved);
-      }
-      return resolved;
-    }
-    return origResolveFilename.call(this, request, parent, isMain, options);
-  };
-
-  if (!withClassicTranspile) return;
-
-  // require.extensions: transpile via the SAME loadTranspile the load hook uses —
-  // target:'es2022' lowering (`using`), tsconfig, source maps, the Stage-3
-  // decorator guard, and module-format detection are all identical to the fast
-  // tier. The path is already a real TS file (Module._resolveFilename ran first).
-  // A module-format source can't be _compile'd as CJS — same clean error as above.
-  const transpileExtension = (mod, filename) => {
-    const { source, format } = loadTranspile(pathToFileURL(filename).href, pathExtname(filename));
-    if (format === "module") throw requireEsmError(filename);
-    mod._compile(source, filename);
-  };
-  for (const ext of [".ts", ".cts", ".mts", ".tsx", ".jsx"]) {
-    module._extensions[ext] = transpileExtension;
-  }
-}
-
-// ── Pre-load clobbered polyfill packages BEFORE hooks register ──────
-// Packages in the core's CLOBBER_MAP can't be imported after hooks register
-// because the resolve hook returns a synthetic module instead of the real
-// package. Load them here via CJS require (not yet hooked) and stash them.
-// Temporal is the exception (A37): the polyfill is ~18ms to load and most scripts
-// never touch it, so we only RESOLVE its path now (cheap) and defer the load to a
-// lazy global getter (below). Requiring it later by absolute path bypasses the
-// CLOBBER_MAP resolve-hook entry, which keys on the "@js-temporal/polyfill"
-// specifier — not the resolved path.
-const __preloadedPolyfills = {};
-// Feature-detect before requiring (A39): URLPattern is native on Node 24+, so
-// skip loading the polyfill there. On 22.x it's absent → load it.
-if (typeof globalThis.URLPattern === "undefined") {
-  try { __preloadedPolyfills.urlpattern = __require("urlpattern-polyfill"); } catch {}
-}
-// Float16Array: native on Node 24+, absent on the 22.x floor.
-if (typeof globalThis.Float16Array === "undefined") {
-  try { __preloadedPolyfills.float16 = __require("@petamoriken/float16"); } catch {}
-}
-let __temporalPath;
-try { __temporalPath = __require.resolve("@js-temporal/polyfill"); } catch {}
-
-// ── Tier dispatch ───────────────────────────────────────────────────
-// Three tiers per wiki/research/supported-node-versions.md:
-//   - >= 22.15.0:         sync module.registerHooks (fast path, in-thread)
-//   - >= 18.19.0 < 22.15: async module.register (loader worker) + main-thread
-//                         CJS require() shim (module.register is ESM-only)
-//   - <  18.19.0:         unsupported (Rust spawn path hard-errors; defensive log)
-//
-// No user-visible distinction between the two augmentation tiers — both deliver
-// the identical feature surface, silently. The compat-mode notice was dropped
-// 2026-05-29 (it labeled a purely internal mechanism choice).
-const __nodeVersionParts = process.versions.node.split(".").map((n) => parseInt(n, 10));
-const __nodeMajor = __nodeVersionParts[0] || 0;
-const __nodeMinor = __nodeVersionParts[1] || 0;
-const __isAugmentedTier = __nodeMajor > 22 || (__nodeMajor === 22 && __nodeMinor >= 15);
-const __isCompatTier = !__isAugmentedTier && (__nodeMajor > 18 || (__nodeMajor === 18 && __nodeMinor >= 19));
-// Native TypeScript support (`process.features.typescript` is "strip"/"transform"
-// — Node 22.18+/24+). Where present, Node loads `.ts` from require() itself,
-// INCLUDING ES-module `.ts` via native require(esm); registering the classic
-// `require.extensions['.ts']` shim there would shadow that and break
-// `require("./esm.ts")`. Where absent (≤ 22.17 / the whole compat tier), Node can't
-// load a required `.ts` on its own, so the shim is required — it transpiles CJS
-// content and surfaces a clean error for ES-module content (which require() can't
-// load there anyway). Feature-detected, not version-gated.
+const common = __require("./preload-common.cjs");
+const { installSyncPolyfills } = __require("./polyfills.cjs");
+
+// ── Tier detection ──────────────────────────────────────────────────
+// This `.mjs` preload should only ever be `--import`ed for the compat tier (the
+// Rust spawn path chooses `--require preload.cjs` for 22.15+). But guard anyway: if
+// someone `--import`s it directly on an unsupported Node, emit a clear message and
+// skip hook registration rather than throw (throwing breaks user-invoked --import
+// flows). The fast-tier branch is intentionally absent here — 22.15+ goes through
+// preload.cjs.
+const [__major = 0, __minor = 0] = process.versions.node.split(".").map((n) => parseInt(n, 10));
+const __isCompatTier = __major > 18 || (__major === 18 && __minor >= 19);
+const __isFastTier = __major > 22 || (__major === 22 && __minor >= 15);
+
+// Native TypeScript support (`process.features.typescript`). Where absent (the
+// whole compat tier ≤ 22.17), Node can't load a required `.ts` on its own, so the
+// classic require.extensions transpile shim is installed; where present it's
+// skipped so Node's native require() of `.ts` isn't shadowed.
 const __hasNativeTs = !!process.features?.typescript;
 
-if (__isAugmentedTier) {
-  // Fast path: sync, in-thread hooks. Same realm as user code; covers `import` and
-  // (Node 24+) `require`. registerHooks' require RESOLUTION is incomplete on
-  // 22.15–24, so also install the main-thread resolve shim. Install the classic
-  // require.extensions transpile shim only on 22.15–22.17 (no native `.ts`); on
-  // 22.18+/24+ skip it so Node's native require() of `.ts` — incl. ES modules —
-  // isn't shadowed (see installCjsRequireHooks).
+// Watch reporting + the Temporal lazy global are tier-independent.
+common.installWatchReporting(core);
+
+if (__isFastTier) {
+  // Defensive only — the Rust path uses preload.cjs for 22.15+. If reached, the
+  // sync registerHooks API is available; register synchronously to stay correct.
+  const { resolve, load } = common.makeHooks(core, process.env.WATCH_REPORT_DEPENDENCIES === "1");
   module.registerHooks({ resolve, load });
-  installCjsRequireHooks(!__hasNativeTs);
+  common.installCjsRequireHooks(core, !__hasNativeTs);
 } else if (__isCompatTier) {
   // Compat path: ESM `import` hooks run in a dedicated loader worker thread.
   module.register("./preload-async-hooks.mjs", import.meta.url);
   // The main-thread CommonJS require() shim's format detection is synchronous and
-  // reaches down to Node 18.19, where `require("oxc-parser")` (ESM-only) fails —
-  // so preload the parser via dynamic import now, while we can still await.
-  await ensureParser();
+  // reaches down to Node 18.19, where `require("oxc-parser")` (ESM-only) fails — so
+  // preload the parser via dynamic import now, while we can still await.
+  await core.ensureParser();
   // module.register() is ESM-loader-only; augment CommonJS require() on the main
   // thread too. The compat tier never has native `.ts`, so it always installs the
   // classic transpile shim (CJS transpile + clean error for ES-module require()).
-  installCjsRequireHooks(!__hasNativeTs);
+  common.installCjsRequireHooks(core, !__hasNativeTs);
 } else {
-  // Defensive: Rust spawn path hard-errors on < 18.19 before reaching here. If
-  // invoked directly via `node --import`, emit a clear message and skip hook
-  // registration rather than throw (throwing breaks user-invoked --import flows).
   process.stderr.write(
     `Nub requires Node 18.19 or newer for runtime augmentation; got ${process.versions.node}. Preload is inactive.\n`,
   );
 }
 
-// ── Polyfill preloads (tier-independent) ────────────────────────────
-// Polyfills install identically on both augmented and compat paths.
-globalThis.__nubPreloaded = __preloadedPolyfills;
-await import("./polyfills.mjs");
-delete globalThis.__nubPreloaded;
-
-// ── Temporal: lazy global (A37) ─────────────────────────────────────
-// Temporal ships in no supported Node, so nub always provides it — but the
-// polyfill is ~18ms to load and rarely used, so install a lazy getter that loads
-// it (by resolved path, bypassing the clobber) on first access. The CLOBBER
-// re-export of `import "@js-temporal/polyfill"` reads globalThis.Temporal, so a
-// user importing the package triggers this same one-time load. A plain assignment
-// (`globalThis.Temporal = …`) replaces the accessor with the value.
-if (typeof globalThis.Temporal === "undefined" && __temporalPath) {
-  const defineTemporal = (value) =>
-    Object.defineProperty(globalThis, "Temporal", {
-      value,
-      configurable: true,
-      writable: true,
-      enumerable: false,
-    });
-  Object.defineProperty(globalThis, "Temporal", {
-    configurable: true,
-    enumerable: false,
-    get() {
-      const polyfill = __require(__temporalPath);
-      // @js-temporal/polyfill exports `toTemporalInstant` as a function but does
-      // NOT auto-install it on Date.prototype (you assign it yourself). Install it
-      // here so that on the floor (no native Temporal) `date.toTemporalInstant()`
-      // AND the package clobber's re-export of `Date.prototype.toTemporalInstant`
-      // both work — matching native Node. Guarded so we never replace a native
-      // implementation on a runtime that ships Temporal.
-      if (
-        typeof Date.prototype.toTemporalInstant !== "function" &&
-        typeof polyfill.toTemporalInstant === "function"
-      ) {
-        Object.defineProperty(Date.prototype, "toTemporalInstant", {
-          value: polyfill.toTemporalInstant,
-          configurable: true,
-          writable: true,
-          enumerable: false,
-        });
-      }
-      const T = polyfill.Temporal;
-      defineTemporal(T);
-      return T;
-    },
-    set: defineTemporal,
-  });
+// ── Clobbered-polyfill preloading + polyfills ───────────────────────
+// Require the clobbered polyfill packages before the resolve hook would intercept
+// them, then install the sync globals (shared with the fast tier) and the two ESM
+// side-effect modules. On the compat tier `require(esm)` of the worker/navigator
+// modules is unreliable, so they load via dynamic `import()` here.
+const __preloadedPolyfills = common.preloadPolyfillPackages(__require);
+installSyncPolyfills(__preloadedPolyfills);
+if (typeof globalThis.navigator?.locks === "undefined") {
+  await import("./navigator-locks.mjs");
 }
+await import("./worker-polyfill.mjs");
 
-// Watch-mode dependency reporting is incremental — see reportWatchDep + the
-// injected core hooks. Config deps are reported as the loader discovers each user
-// file, plus their `.env*` siblings.
+// ── Temporal: lazy global (A37) ─────────────────────────────────────
+common.installTemporalLazyGlobal(__require);
+
+// ── Compile-cache: re-enable for the USER's modules (R8) ────────────
+// spawn.rs strips NODE_COMPILE_CACHE for every augmented spawn (both tiers), so
+// nub's preload chain is never cached into the user's dir. Re-point the cache at
+// the user's original dir (via the PID-keyed sentinel) so their own modules still
+// cache. `module.enableCompileCache` only exists on Node 22.8+, so on most of the
+// compat tier (< 22.8) this is a safe no-op; it benefits 22.8–22.14 users who set
+// NODE_COMPILE_CACHE. See reenableUserCompileCache for the full rationale.
+common.reenableUserCompileCache();

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.13";

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");