@nubjs/nub-linux-x64-musl 0.0.1 → 0.0.2

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "@nubjs/nub-linux-x64-musl",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Nub binary for linux-x64-musl",
   "license": "MIT",
   "repository": "https://github.com/colinhacks/nub",
-  "os": ["linux"],
-  "cpu": ["x64"],
-  "files": ["bin", "runtime"]
-}
+  "os": [
+    "linux"
+  ],
+  "cpu": [
+    "x64"
+  ],
+  "files": [
+    "bin",
+    "runtime"
+  ],
+  "libc": [
+    "musl"
+  ]
+}

package/runtime/navigator-locks.mjs

@@ -0,0 +1,135 @@
+// Web Locks API polyfill for Node 22.x (native on Node 24.5+).
+// Single-process only — locks don't coordinate across workers.
+
+if (typeof globalThis.navigator === "object" && typeof globalThis.navigator.locks === "undefined") {
+  // Track held locks: name → { mode, count } where count > 1 means shared holders
+  const held = new Map();
+  const queue = new Map();
+
+  class Lock {
+    #name;
+    #mode;
+    constructor(name, mode) {
+      this.#name = name;
+      this.#mode = mode;
+    }
+    get name() { return this.#name; }
+    get mode() { return this.#mode; }
+  }
+
+  function canAcquire(name, mode) {
+    const current = held.get(name);
+    if (!current) return true;
+    if (mode === "shared" && current.mode === "shared") return true;
+    return false;
+  }
+
+  function acquire(name, mode) {
+    const current = held.get(name);
+    if (current && mode === "shared" && current.mode === "shared") {
+      current.count++;
+    } else {
+      held.set(name, { mode, count: 1 });
+    }
+  }
+
+  function release(name) {
+    const current = held.get(name);
+    if (!current) return;
+    current.count--;
+    if (current.count <= 0) {
+      held.delete(name);
+      drainQueue(name);
+    }
+  }
+
+  function drainQueue(name) {
+    const q = queue.get(name);
+    if (!q || q.length === 0) return;
+
+    // Try to grant as many queued requests as possible.
+    // If the first queued is shared, grant all consecutive shared requests.
+    // If the first queued is exclusive, grant only that one.
+    const first = q[0];
+    if (canAcquire(name, first.mode)) {
+      if (first.mode === "exclusive") {
+        q.shift();
+        first.resolve();
+      } else {
+        // Grant all consecutive shared requests.
+        while (q.length > 0 && q[0].mode === "shared") {
+          const req = q.shift();
+          req.resolve();
+        }
+      }
+    }
+  }
+
+  class LockManager {
+    async request(name, optionsOrCallback, callback) {
+      let options = {};
+      if (typeof optionsOrCallback === "function") {
+        callback = optionsOrCallback;
+      } else {
+        options = optionsOrCallback || {};
+      }
+
+      const mode = options.mode || "exclusive";
+      const ifAvailable = options.ifAvailable || false;
+      const signal = options.signal;
+
+      if (signal?.aborted) {
+        throw signal.reason || new DOMException("Lock request aborted", "AbortError");
+      }
+
+      if (!canAcquire(name, mode)) {
+        if (ifAvailable) {
+          return callback(null);
+        }
+        await new Promise((resolve, reject) => {
+          if (!queue.has(name)) queue.set(name, []);
+          queue.get(name).push({ resolve, reject, mode });
+          if (signal) {
+            signal.addEventListener("abort", () => {
+              const q = queue.get(name) || [];
+              const idx = q.findIndex((e) => e.resolve === resolve);
+              if (idx !== -1) q.splice(idx, 1);
+              reject(signal.reason || new DOMException("Lock request aborted", "AbortError"));
+            }, { once: true });
+          }
+        });
+      }
+
+      acquire(name, mode);
+      const lock = new Lock(name, mode);
+
+      try {
+        return await callback(lock);
+      } finally {
+        release(name);
+      }
+    }
+
+    async query() {
+      const heldLocks = [];
+      for (const [name, info] of held) {
+        for (let i = 0; i < info.count; i++) {
+          heldLocks.push({ name, mode: info.mode, clientId: "" });
+        }
+      }
+      const pending = [];
+      for (const [name, q] of queue) {
+        for (const req of q) {
+          pending.push({ name, mode: req.mode, clientId: "" });
+        }
+      }
+      return { held: heldLocks, pending };
+    }
+  }
+
+  Object.defineProperty(globalThis.navigator, "locks", {
+    value: new LockManager(),
+    enumerable: true,
+    configurable: true,
+  });
+}

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 });
+}

package/runtime/worker-polyfill.mjs

@@ -0,0 +1,91 @@
+// Browser-shape Worker global polyfill for Node.js.
+// 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";
+
+if (typeof globalThis.Worker === "undefined") {
+  class Worker extends EventTarget {
+    #worker;
+
+    constructor(url, options = {}) {
+      super();
+
+      let workerPath;
+      if (url instanceof URL) {
+        workerPath = fileURLToPath(url);
+      } else if (typeof url === "string") {
+        if (url.startsWith("file://")) {
+          workerPath = fileURLToPath(url);
+        } else {
+          workerPath = url;
+        }
+      } else {
+        throw new TypeError("Worker constructor: url must be a string or URL");
+      }
+
+      const type = options.type || "module";
+      this.#worker = new NodeWorker(workerPath, {
+        ...options,
+        eval: false,
+        execArgv: process.execArgv,
+      });
+
+      this.#worker.on("message", (data) => {
+        this.dispatchEvent(new MessageEvent("message", { data }));
+      });
+
+      this.#worker.on("messageerror", (err) => {
+        this.dispatchEvent(new MessageEvent("messageerror", { data: err }));
+      });
+
+      this.#worker.on("error", (err) => {
+        this.dispatchEvent(new ErrorEvent("error", { error: err, message: err.message }));
+      });
+
+      this.#worker.on("exit", (code) => {
+        this.dispatchEvent(new Event("exit"));
+      });
+    }
+
+    postMessage(data, transfer) {
+      this.#worker.postMessage(data, transfer);
+    }
+
+    terminate() {
+      return this.#worker.terminate();
+    }
+
+    #onmessageHandler = null;
+    get onmessage() { return this.#onmessageHandler; }
+    set onmessage(fn) {
+      if (this.#onmessageHandler) this.removeEventListener("message", this.#onmessageHandler);
+      this.#onmessageHandler = fn;
+      if (fn) this.addEventListener("message", fn);
+    }
+
+    #onerrorHandler = null;
+    get onerror() { return this.#onerrorHandler; }
+    set onerror(fn) {
+      if (this.#onerrorHandler) this.removeEventListener("error", this.#onerrorHandler);
+      this.#onerrorHandler = fn;
+      if (fn) this.addEventListener("error", fn);
+    }
+  }
+
+  globalThis.Worker = Worker;
+}
+
+// Worker-side bootstrap: set up self, postMessage, close.
+if (!isMainThread && parentPort) {
+  if (typeof globalThis.self === "undefined") {
+    globalThis.self = globalThis;
+  }
+  if (typeof globalThis.postMessage === "undefined") {
+    globalThis.postMessage = (data, transfer) => parentPort.postMessage(data, transfer);
+  }
+  if (typeof globalThis.close === "undefined") {
+    globalThis.close = () => process.exit(0);
+  }
+}