@nubjs/nub-darwin-arm64 0.0.1

package/runtime/preload.mjs

@@ -0,0 +1,355 @@
+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;
+  }
+
+  // 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",
+    };
+  }
+
+  const result = transformSync(filePath, source, opts);
+  if (result.errors.length > 0) {
+    throw new Error(`Transpile error in ${filePath}:\n${result.errors.map((e) => e.message).join("\n")}`);
+  }
+
+  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);
+  }
+}