@nubjs/nub-win32-x64 0.0.1 → 0.0.2

package/runtime/node_modules/oxc-transform/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "oxc-transform",
+  "version": "0.132.0",
+  "description": "Oxc Transformer Node API",
+  "keywords": [
+    "babel",
+    "javascript",
+    "jsx",
+    "oxc",
+    "transform",
+    "transformer",
+    "tsx",
+    "typescript"
+  ],
+  "homepage": "https://oxc.rs/docs/guide/usage/transformer",
+  "bugs": "https://github.com/oxc-project/oxc/issues",
+  "license": "MIT",
+  "author": "Boshen and oxc contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxc-project/oxc.git",
+    "directory": "napi/transform"
+  },
+  "funding": {
+    "url": "https://github.com/sponsors/Boshen"
+  },
+  "files": [
+    "browser.js",
+    "index.d.ts",
+    "index.js",
+    "webcontainer-fallback.cjs"
+  ],
+  "type": "module",
+  "main": "index.js",
+  "browser": "browser.js",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@emnapi/core": "1.10.0",
+    "@emnapi/runtime": "1.10.0",
+    "@napi-rs/cli": "3.6.2",
+    "@types/node": "24.1.0",
+    "publint": "0.3.21",
+    "vitest": "4.1.6"
+  },
+  "napi": {
+    "binaryName": "transform",
+    "packageName": "@oxc-transform/binding",
+    "targets": [
+      "aarch64-apple-darwin",
+      "aarch64-linux-android",
+      "aarch64-pc-windows-msvc",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "aarch64-unknown-linux-ohos",
+      "armv7-linux-androideabi",
+      "armv7-unknown-linux-gnueabihf",
+      "armv7-unknown-linux-musleabihf",
+      "i686-pc-windows-msvc",
+      "powerpc64le-unknown-linux-gnu",
+      "riscv64gc-unknown-linux-gnu",
+      "riscv64gc-unknown-linux-musl",
+      "s390x-unknown-linux-gnu",
+      "wasm32-wasip1-threads",
+      "x86_64-apple-darwin",
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-freebsd",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl"
+    ],
+    "wasm": {
+      "browser": {
+        "fs": false
+      }
+    }
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "optionalDependencies": {
+    "@oxc-transform/binding-darwin-arm64": "0.132.0",
+    "@oxc-transform/binding-android-arm64": "0.132.0",
+    "@oxc-transform/binding-win32-arm64-msvc": "0.132.0",
+    "@oxc-transform/binding-linux-arm64-gnu": "0.132.0",
+    "@oxc-transform/binding-linux-arm64-musl": "0.132.0",
+    "@oxc-transform/binding-openharmony-arm64": "0.132.0",
+    "@oxc-transform/binding-android-arm-eabi": "0.132.0",
+    "@oxc-transform/binding-linux-arm-gnueabihf": "0.132.0",
+    "@oxc-transform/binding-linux-arm-musleabihf": "0.132.0",
+    "@oxc-transform/binding-win32-ia32-msvc": "0.132.0",
+    "@oxc-transform/binding-linux-ppc64-gnu": "0.132.0",
+    "@oxc-transform/binding-linux-riscv64-gnu": "0.132.0",
+    "@oxc-transform/binding-linux-riscv64-musl": "0.132.0",
+    "@oxc-transform/binding-linux-s390x-gnu": "0.132.0",
+    "@oxc-transform/binding-wasm32-wasi": "0.132.0",
+    "@oxc-transform/binding-darwin-x64": "0.132.0",
+    "@oxc-transform/binding-win32-x64-msvc": "0.132.0",
+    "@oxc-transform/binding-freebsd-x64": "0.132.0",
+    "@oxc-transform/binding-linux-x64-gnu": "0.132.0",
+    "@oxc-transform/binding-linux-x64-musl": "0.132.0"
+  },
+  "scripts": {
+    "build-dev": "napi build --esm --platform",
+    "build-test": "pnpm run build-dev --profile coverage",
+    "build": "pnpm run build-dev --features allocator --release",
+    "postbuild": "publint",
+    "postbuild-dev": "node scripts/patch.js",
+    "build-wasm": "pnpm run build-wasm-dev --release",
+    "build-wasm-dev": "pnpm run build-dev --target wasm32-wasip1-threads",
+    "test": "vitest run --dir ./test"
+  }
+}

package/runtime/node_modules/oxc-transform/webcontainer-fallback.cjs

@@ -0,0 +1,21 @@
+const fs = require("node:fs");
+const childProcess = require("node:child_process");
+
+const pkg = JSON.parse(fs.readFileSync(require.resolve("oxc-transform/package.json"), "utf-8"));
+const { version } = pkg;
+const baseDir = `/tmp/oxc-transform-${version}`;
+const bindingEntry = `${baseDir}/node_modules/@oxc-transform/binding-wasm32-wasi/transform.wasi.cjs`;
+
+if (!fs.existsSync(bindingEntry)) {
+  fs.rmSync(baseDir, { recursive: true, force: true });
+  fs.mkdirSync(baseDir, { recursive: true });
+  const bindingPkg = `@oxc-transform/binding-wasm32-wasi@${version}`;
+  // oxlint-disable-next-line no-console
+  console.log(`[oxc-transform] Downloading ${bindingPkg} on WebContainer...`);
+  childProcess.execFileSync("pnpm", ["i", bindingPkg], {
+    cwd: baseDir,
+    stdio: "inherit",
+  });
+}
+
+module.exports = require(bindingEntry);

package/runtime/polyfills.mjs

@@ -0,0 +1,160 @@
+// 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 (not in any Node version) ──────────────────────────────
+if (typeof globalThis.Temporal === "undefined") {
+  const mod = globalThis.__nubPreloaded?.temporal;
+  const Temporal = mod?.Temporal;
+  if (Temporal) globalThis.Temporal = Temporal;
+}
+
+// ── Stage 4 polyfills (native on Node 24+, missing on 22.x) ────────
+
+// RegExp.escape
+if (typeof RegExp.escape !== "function") {
+  const escapeRe = /[\\^$.*+?()[\]{}|]/g;
+  RegExp.escape = (s) => String(s).replace(escapeRe, "\\$&");
+}
+
+// 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+)
+// Partial TypedArray integration: instanceof TypedArray works via
+// prototype chain setup, but ArrayBuffer.isView() returns false
+// (requires V8 internal slots we can't set from userland).
+if (typeof globalThis.Float16Array === "undefined") {
+  const TypedArray = Object.getPrototypeOf(Uint8Array);
+  const buf = new ArrayBuffer(2);
+  const f32 = new Float32Array(1);
+  const u32 = new Uint32Array(f32.buffer);
+  const u16view = new Uint16Array(buf);
+
+  function f32ToF16(val) {
+    f32[0] = val;
+    const bits = u32[0];
+    const sign = (bits >> 16) & 0x8000;
+    const exp = ((bits >> 23) & 0xff) - 127 + 15;
+    const frac = (bits >> 13) & 0x3ff;
+    if (exp <= 0) return sign;
+    if (exp >= 31) return sign | 0x7c00 | (frac ? 1 : 0);
+    return sign | (exp << 10) | frac;
+  }
+
+  function f16ToF32(h) {
+    const sign = (h & 0x8000) >> 15;
+    const exp = (h & 0x7c00) >> 10;
+    const frac = h & 0x03ff;
+    if (exp === 0) {
+      if (frac === 0) return sign ? -0 : 0;
+      let e = -1;
+      let f = frac;
+      while ((f & 0x400) === 0) { f <<= 1; e--; }
+      f &= 0x3ff;
+      u32[0] = (sign << 31) | ((e + 127) << 23) | (f << 13);
+      return f32[0];
+    }
+    if (exp === 31) {
+      return frac ? NaN : (sign ? -Infinity : Infinity);
+    }
+    u32[0] = (sign << 31) | ((exp - 15 + 127) << 23) | (frac << 13);
+    return f32[0];
+  }
+
+  class Float16Array {
+    #data;
+    constructor(arg) {
+      if (typeof arg === "number") {
+        this.#data = new Uint16Array(arg);
+      } else if (arg instanceof ArrayBuffer || arg instanceof SharedArrayBuffer) {
+        this.#data = new Uint16Array(arg);
+      } else if (ArrayBuffer.isView(arg) || Array.isArray(arg)) {
+        this.#data = new Uint16Array(arg.length);
+        for (let i = 0; i < arg.length; i++) this.#data[i] = f32ToF16(Number(arg[i]));
+      } else {
+        this.#data = new Uint16Array(0);
+      }
+      this.length = this.#data.length;
+      this.byteLength = this.#data.byteLength;
+      this.byteOffset = this.#data.byteOffset;
+      this.buffer = this.#data.buffer;
+      this.BYTES_PER_ELEMENT = 2;
+      return new Proxy(this, {
+        get(target, prop) {
+          if (typeof prop === "string" && /^\d+$/.test(prop)) return f16ToF32(target.#data[prop]);
+          return Reflect.get(target, prop);
+        },
+        set(target, prop, value) {
+          if (typeof prop === "string" && /^\d+$/.test(prop)) { target.#data[prop] = f32ToF16(Number(value)); return true; }
+          return Reflect.set(target, prop, value);
+        },
+      });
+    }
+    [Symbol.iterator]() { let i = 0; const d = this.#data; return { next: () => i < d.length ? { value: f16ToF32(d[i++]), done: false } : { done: true } }; }
+    static get BYTES_PER_ELEMENT() { return 2; }
+  }
+
+  // Set up prototype chain so `instanceof TypedArray` works.
+  Object.setPrototypeOf(Float16Array.prototype, TypedArray.prototype);
+  Object.setPrototypeOf(Float16Array, TypedArray);
+
+  globalThis.Float16Array = Float16Array;
+
+  if (typeof DataView.prototype.getFloat16 !== "function") {
+    DataView.prototype.getFloat16 = function (offset, le) {
+      return f16ToF32(this.getUint16(offset, le));
+    };
+    DataView.prototype.setFloat16 = function (offset, value, le) {
+      this.setUint16(offset, f32ToF16(value), le);
+    };
+  }
+
+  if (typeof Math.f16round !== "function") {
+    Math.f16round = (x) => f16ToF32(f32ToF16(x));
+  }
+}
+
+// ── 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");

package/runtime/preload.mjs

@@ -0,0 +1,363 @@
+import module from "node:module";
+import { readFileSync, writeFileSync, mkdirSync, statSync } 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";
+
+const __require = createRequire(import.meta.url);
+
+// ── Constants ───────────────────────────────────────────────────────
+const TRANSPILE_EXTS = new Set([".ts", ".tsx", ".mts", ".cts", ".jsx"]);
+const DATA_EXTS = { ".jsonc": "jsonc", ".json5": "json5", ".toml": "toml", ".yaml": "yaml", ".yml": "yaml", ".txt": "txt" };
+const TS_PARENT_EXTS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+
+// Nub's N-API addon for data-format parsing (Rust-native YAML/TOML/JSON5/JSONC).
+let nubNative = null;
+for (const rel of ["./addons/nub-native.node", "../runtime/addons/nub-native.node"]) {
+  try { nubNative = __require(fileURLToPath(new URL(rel, import.meta.url))); break; } catch {}
+}
+
+// Packages resolved from Nub's distribution, not the user's.
+const VENDORED_PACKAGES = new Set(["@oxc-project/runtime"]);
+
+// Built-in modules provided by Nub (resolved to files in this distribution).
+// connect() sockets deferred per design decision — "sockets" specifier not clobbered.
+const BUILTIN_MODULES = new Map();
+
+// Package clobbering: specifiers that resolve to a synthetic module
+// re-exporting the native global instead of the userland package.
+const CLOBBER_MAP = new Map([
+  ["@js-temporal/polyfill", () => `const T = globalThis.Temporal; export default T; export const Temporal = T;`],
+  ["urlpattern-polyfill", () => `export const URLPattern = globalThis.URLPattern;`],
+  ["abort-controller", () => `export const AbortController = globalThis.AbortController; export const AbortSignal = globalThis.AbortSignal; export default globalThis.AbortController;`],
+]);
+
+// ── tsconfig cache ──────────────────────────────────────────────────
+const tsconfigCache = new Map();
+
+function getTsconfigForDir(dir) {
+  if (tsconfigCache.has(dir)) return tsconfigCache.get(dir);
+  const result = getTsconfig(dir);
+  const matcher = result ? createPathsMatcher(result) : null;
+  const entry = { tsconfig: result, matcher };
+  tsconfigCache.set(dir, entry);
+  return entry;
+}
+
+// ── Transpile cache ─────────────────────────────────────────────────
+const NUB_VERSION = "0.1.0";
+const CACHE_DISABLED = process.permission?.has !== undefined;
+let cacheDir = null;
+
+if (!CACHE_DISABLED) {
+  const base = process.env.XDG_CACHE_HOME || (process.env.HOME ? join(process.env.HOME, ".cache") : null);
+  if (base) {
+    cacheDir = join(base, "nub", "transpile");
+    try { mkdirSync(cacheDir, { recursive: true }); } catch { cacheDir = null; }
+  }
+}
+
+function cacheKey(source) {
+  return createHash("sha256").update(NUB_VERSION).update("\0").update(source).digest("hex");
+}
+function cacheGet(key) {
+  if (!cacheDir) return null;
+  const path = join(cacheDir, key);
+  const s = statSync(path, { throwIfNoEntry: false });
+  if (!s || !s.isFile()) return null;
+  return readFileSync(path, "utf8");
+}
+function cacheSet(key, value) {
+  if (!cacheDir) return;
+  try { writeFileSync(join(cacheDir, key), value); } catch {}
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+function extname(url) {
+  const path = url.includes("?") ? url.slice(0, url.indexOf("?")) : url;
+  const dot = path.lastIndexOf(".");
+  return dot === -1 ? "" : path.slice(dot);
+}
+
+function isNodeModules(url) {
+  return url.includes("/node_modules/") || url.includes("\\node_modules\\");
+}
+
+function fileExists(filePath) {
+  const s = statSync(filePath, { throwIfNoEntry: false });
+  return s !== undefined && s.isFile();
+}
+
+function dirExists(filePath) {
+  const s = statSync(filePath, { throwIfNoEntry: false });
+  return s !== undefined && s.isDirectory();
+}
+
+function safeRequireResolve(specifier) {
+  try { return __require.resolve(specifier); } catch { return null; }
+}
+
+function barePkg(specifier) {
+  return specifier.startsWith("@")
+    ? specifier.split("/").slice(0, 2).join("/")
+    : specifier.split("/")[0];
+}
+
+// ── Resolve hook ────────────────────────────────────────────────────
+function resolve(specifier, context, nextResolve) {
+  // Skip node: and data: protocols.
+  if (specifier.startsWith("node:") || specifier.startsWith("data:")) {
+    return nextResolve(specifier, context);
+  }
+
+  // Skip Node built-in module names (without node: prefix).
+  if (module.builtinModules.includes(specifier)) {
+    return nextResolve(specifier, context);
+  }
+
+  // 1. Built-in modules provided by Nub.
+  if (BUILTIN_MODULES.has(specifier)) {
+    return { url: BUILTIN_MODULES.get(specifier), shortCircuit: true };
+  }
+
+  // 2. Vendored packages (e.g. @oxc-project/runtime).
+  const bare = barePkg(specifier);
+  if (VENDORED_PACKAGES.has(bare)) {
+    const resolved = safeRequireResolve(specifier);
+    if (resolved) return { url: pathToFileURL(resolved).href, shortCircuit: true };
+  }
+
+  // 2. Package clobbering.
+  if (CLOBBER_MAP.has(bare) && !isNodeModules(context.parentURL || "")) {
+    return { url: `data:text/javascript,${encodeURIComponent(CLOBBER_MAP.get(bare)())}`, shortCircuit: true };
+  }
+
+  // 3. tsconfig-paths (only for bare/aliased specifiers, not relative).
+  const parentURL = String(context.parentURL || "");
+  const parentExt = extname(parentURL);
+  if (!specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && !isNodeModules(parentURL)) {
+    const parentDir = parentURL.startsWith("file:") ? dirname(fileURLToPath(parentURL)) : process.cwd();
+    const { matcher } = getTsconfigForDir(parentDir);
+    if (matcher) {
+      const mapped = matcher(specifier);
+      if (mapped && mapped.length > 0) {
+        for (const candidate of mapped) {
+          const resolved = tryResolveFile(candidate, parentExt);
+          if (resolved) {
+            return { url: pathToFileURL(resolved).href, shortCircuit: true };
+          }
+        }
+      }
+    }
+  }
+
+  // 4. Extensionless probing (only when parent is a TS file).
+  if (TS_PARENT_EXTS.has(parentExt) && (specifier.startsWith("./") || specifier.startsWith("../"))) {
+    const parentDir = dirname(fileURLToPath(parentURL));
+    const target = pathResolve(parentDir, specifier);
+    const resolved = tryResolveFile(target, parentExt);
+    if (resolved) {
+      return { url: pathToFileURL(resolved).href, shortCircuit: true };
+    }
+  }
+
+  return nextResolve(specifier, context);
+}
+
+// Try to resolve a file path with extensionless probing + .js→.ts swap.
+function tryResolveFile(target, parentExt) {
+  // If the target already has an extension and exists, use it.
+  const existingExt = pathExtname(target);
+  if (existingExt && fileExists(target)) return target;
+
+  // .js → .ts swap (tsc emit convention reversal).
+  if (existingExt === ".js") {
+    const tsSwap = target.slice(0, -3) + ".ts";
+    if (fileExists(tsSwap)) return tsSwap;
+    const tsxSwap = target.slice(0, -3) + ".tsx";
+    if (fileExists(tsxSwap)) return tsxSwap;
+  }
+  if (existingExt === ".jsx") {
+    const tsxSwap = target.slice(0, -4) + ".tsx";
+    if (fileExists(tsxSwap)) return tsxSwap;
+  }
+  // .mjs → .mts swap (Bun does this).
+  if (existingExt === ".mjs") {
+    const mtsSwap = target.slice(0, -4) + ".mts";
+    if (fileExists(mtsSwap)) return mtsSwap;
+  }
+
+  // Extensionless: probe in parent-ext-aware order.
+  if (!existingExt) {
+    const probeOrder = getProbeOrder(parentExt);
+    for (const ext of probeOrder) {
+      if (fileExists(target + ext)) return target + ext;
+    }
+    // Directory index probing.
+    if (dirExists(target)) {
+      for (const ext of probeOrder) {
+        const idx = join(target, "index" + ext);
+        if (fileExists(idx)) return idx;
+      }
+    }
+  }
+
+  return null;
+}
+
+function getProbeOrder(parentExt) {
+  switch (parentExt) {
+    case ".tsx": return [".tsx", ".ts", ".jsx", ".js", ".json"];
+    case ".mts": return [".mts", ".mjs"];
+    case ".cts": return [".cts", ".cjs"];
+    default:     return [".ts", ".tsx", ".js", ".jsx", ".json"];
+  }
+}
+
+// ── Load hook ───────────────────────────────────────────────────────
+function load(url, context, nextLoad) {
+  const ext = extname(url);
+
+  if (TRANSPILE_EXTS.has(ext)) return loadTranspile(url, ext);
+  if (ext in DATA_EXTS) return loadData(url, ext);
+
+  return nextLoad(url, context);
+}
+
+function loadTranspile(url, ext) {
+  const filePath = fileURLToPath(url);
+  const source = readFileSync(filePath, "utf8");
+  const dir = dirname(filePath);
+  const { tsconfig } = getTsconfigForDir(dir);
+  const co = tsconfig?.config?.compilerOptions;
+
+  // Cache key includes tsconfig compilerOptions so tsconfig changes invalidate.
+  const tsconfigHash = co ? JSON.stringify(co) : "";
+  const key = cacheKey(source + "\0" + ext + "\0" + tsconfigHash);
+  const cached = cacheGet(key);
+  if (cached) {
+    return { format: ext === ".cts" ? "commonjs" : "module", source: cached, shortCircuit: true };
+  }
+
+  const lang = ext === ".tsx" ? "tsx" : ext === ".jsx" ? "jsx" : "ts";
+  const opts = {
+    lang,
+    sourceType: ext === ".cts" ? "commonjs" : "module",
+    sourcemap: true,
+    typescript: {},
+    decorator: co?.experimentalDecorators !== false
+      ? { legacy: true, emitDecoratorMetadata: co?.emitDecoratorMetadata !== false }
+      : undefined,
+  };
+  if (ext === ".tsx" || ext === ".jsx") {
+    opts.jsx = {
+      runtime: co?.jsx === "react" ? "classic" : "automatic",
+      importSource: co?.jsxImportSource || "react",
+    };
+    if (co?.jsxFactory) opts.jsx.pragma = co.jsxFactory;
+    if (co?.jsxFragmentFactory) opts.jsx.pragmaFrag = co.jsxFragmentFactory;
+  }
+
+  const result = transformSync(filePath, source, opts);
+  if (result.errors.length > 0) {
+    const details = result.errors.map((e) => e.codeframe || e.message).join("\n\n");
+    throw new Error(`Transpile error in ${filePath}:\n${details}`);
+  }
+
+  let code = result.code;
+  if (result.map) {
+    const map = typeof result.map === "string" ? JSON.parse(result.map) : result.map;
+    map.sourcesContent = [source];
+    code += `\n//# sourceMappingURL=data:application/json;base64,${Buffer.from(JSON.stringify(map)).toString("base64")}\n`;
+  }
+
+  cacheSet(key, code);
+  return { format: ext === ".cts" ? "commonjs" : "module", source: code, shortCircuit: true };
+}
+
+function loadData(url, ext) {
+  const filePath = fileURLToPath(url);
+  const raw = readFileSync(filePath, "utf8");
+  const kind = DATA_EXTS[ext];
+
+  if (kind === "txt") {
+    return { format: "module", source: `export default ${JSON.stringify(raw)};\n`, shortCircuit: true };
+  }
+
+  let parsed;
+  if (nubNative) {
+    if (kind === "yaml") parsed = nubNative.parseYaml(raw);
+    else if (kind === "toml") parsed = nubNative.parseToml(raw);
+    else if (kind === "json5") parsed = nubNative.parseJson5(raw);
+    else if (kind === "jsonc") parsed = nubNative.parseJsonc(raw);
+  } else {
+    if (kind === "yaml") parsed = lazyRequire("yaml").parse(raw);
+    else if (kind === "toml") parsed = lazyRequire("@iarna/toml").parse(raw);
+    else if (kind === "json5") parsed = lazyRequire("json5").parse(raw);
+    else if (kind === "jsonc") parsed = JSON.parse(stripJsonComments(raw));
+  }
+
+  if (parsed == null) {
+    return { format: "module", source: "export default undefined;\n", shortCircuit: true };
+  }
+
+  let code = `const _data = ${JSON.stringify(parsed)};\nexport default _data;\n`;
+  if (typeof parsed === "object" && !Array.isArray(parsed)) {
+    for (const key of Object.keys(parsed)) {
+      if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+        code += `export const ${key} = _data[${JSON.stringify(key)}];\n`;
+      }
+    }
+  }
+  return { format: "module", source: code, shortCircuit: true };
+}
+
+function lazyRequire(pkg) {
+  try { return __require(pkg); } catch {
+    throw new Error(`Nub: importing this file requires the "${pkg}" package.\nInstall it: npm install ${pkg}`);
+  }
+}
+
+function stripJsonComments(text) {
+  let result = "", i = 0, inString = false, escape = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (escape) { result += ch; escape = false; i++; continue; }
+    if (inString) { if (ch === "\\") escape = true; if (ch === '"') inString = false; result += ch; i++; continue; }
+    if (ch === '"') { inString = true; result += ch; i++; continue; }
+    if (ch === "/" && text[i + 1] === "/") { while (i < text.length && text[i] !== "\n") i++; continue; }
+    if (ch === "/" && text[i + 1] === "*") { i += 2; while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++; i += 2; continue; }
+    result += ch; i++;
+  }
+  return result;
+}
+
+// ── Pre-load clobbered polyfill packages BEFORE hooks register ──────
+// Packages in 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 (which isn't yet hooked) and stash them.
+const __preloadedPolyfills = {};
+try { __preloadedPolyfills.temporal = __require("@js-temporal/polyfill"); } catch {}
+try { __preloadedPolyfills.urlpattern = __require("urlpattern-polyfill"); } catch {}
+
+// ── Register hooks ──────────────────────────────────────────────────
+module.registerHooks({ resolve, load });
+
+// ── Polyfill preloads ───────────────────────────────────────────────
+globalThis.__nubPreloaded = __preloadedPolyfills;
+await import("./polyfills.mjs");
+delete globalThis.__nubPreloaded;
+delete globalThis.__nubRequire;
+delete globalThis.__nubRequire;
+
+// ── Watch-mode dependency reporting ─────────────────────────────────
+if (process.env.WATCH_REPORT_DEPENDENCIES === "1" && process.send) {
+  const deps = [];
+  for (const [, entry] of tsconfigCache) {
+    if (entry.tsconfig?.path) deps.push(entry.tsconfig.path);
+  }
+  if (deps.length > 0) process.send({ "watch:require": deps });
+}