@nubjs/nub-darwin-x64 0.2.2 → 0.2.4

package/runtime/pnp-util.cjs

@@ -1,62 +0,0 @@
-// Shared Yarn PnP ESM-resolution helper, used by BOTH realms that resolve ESM
-// imports: the main-thread preload (preload-common.cjs, fast tier) and the
-// compat-tier loader worker (preload-async-hooks.mjs). CJS resolution does NOT live
-// here — it just strips the `conditions` option and delegates to PnP's own patched
-// `_resolveFilename` (see installCjsRequireHooks). ESM is different: PnP does not
-// patch the ESM loader, so `import` of a PnP dep must be resolved explicitly, AND it
-// must pass the *import* conditions — otherwise a dual package (separate `import` /
-// `require` exports) resolves to its CJS build and `import { x }` fails. So we go
-// through `pnpapi.resolveRequest` (the only PnP resolver that accepts conditions).
-const { readFileSync } = require("node:fs");
-const { dirname, join, sep } = require("node:path");
-const { fileURLToPath, pathToFileURL } = require("node:url");
-
-// A directory issuer for resolveRequest: cwd with a trailing separator so PnP treats
-// it as a directory. `path.sep` (not a literal "/") keeps it correct on Windows.
-const cwdIssuer = () => process.cwd() + sep;
-
-// Module format of a resolved file. `.mjs`/`.cjs` are unambiguous; a `.js` file
-// inherits its nearest package's `type`, read by walking up to package.json via the
-// zip-patched `fs` (`.pnp.cjs` patches `fs`, so reads inside `.zip` work in both
-// realms). No pnpapi needed. Defaults to "commonjs" if detection fails.
-function formatOf(resolvedPath) {
-  if (resolvedPath.endsWith(".mjs")) return "module";
-  if (resolvedPath.endsWith(".cjs")) return "commonjs";
-  let dir = dirname(resolvedPath);
-  for (let i = 0; i < 16; i++) {
-    try {
-      const pj = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
-      return pj.type === "module" ? "module" : "commonjs";
-    } catch {}
-    const up = dirname(dir);
-    if (up === dir) break;
-    dir = up;
-  }
-  return "commonjs";
-}
-
-// Resolve a `specifier` through PnP for a hook `context`, applying the correct
-// exports conditions so a dual package resolves to the right build. Returns a Node
-// resolve-hook result `{ url, format, shortCircuit }`, or `null` if PnP can't resolve
-// it (the caller then delegates). Throwing is also a fall-through signal.
-//
-// Conditions: trust `context.conditions` when Node populates it (Node 24+/26 for both
-// import and require; Node 22.15 for import). But Node 22.15 hands the resolve hook
-// an EMPTY `conditions` for a `require()` — so when it's empty, infer the side from
-// `importAttributes` (`undefined` ⇒ a require, an object ⇒ an import) and apply the
-// matching default. Without this a 22.15 `require()` of a dual package would wrongly
-// get the `import` build.
-function pnpResolveEsm(api, specifier, context) {
-  const parentURL = context && context.parentURL;
-  const issuer = parentURL ? fileURLToPath(parentURL) : cwdIssuer();
-  let conds = context && context.conditions;
-  if (!conds || !conds.length) {
-    const isImport = !!context && context.importAttributes !== undefined;
-    conds = isImport ? ["node", "import"] : ["node", "require"];
-  }
-  const resolved = api.resolveRequest(specifier, issuer, { conditions: new Set(conds) });
-  if (!resolved) return null;
-  return { url: pathToFileURL(resolved).href, format: formatOf(resolved), shortCircuit: true };
-}
-
-module.exports = { pnpResolveEsm, cwdIssuer };

package/runtime/polyfills.cjs

@@ -1,278 +0,0 @@
-// Polyfill preloads for Nub v0.1 — the shared implementation for BOTH tiers.
-//
-// This is a CommonJS module with ZERO top-level await so the fast tier
-// (Node 22.15+, `--require` CJS preload) can `require()` it synchronously: a
-// `require()`-loaded preload keeps Node's synchronous `Module.runMain` CJS entry
-// path (top-level `executionAsyncId()===1`, sync exception origin), which the old
-// `--import` ESM preload broke (R1). The compat tier (`--import` preload.mjs)
-// reuses this same logic via the `installSyncPolyfills` export, then loads the two
-// ESM side-effect modules (worker-polyfill, navigator-locks) with dynamic
-// `import()` — on the < 22.15 floor `require()` of an ES module is unreliable.
-//
-// All polyfills feature-detect and bow out if the global is already present.
-//
-// 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. (Temporal is a lazy global
-// installed by the preload entry, NOT here — see preload.cjs / preload.mjs.)
-
-const { createRequire } = require("node:module");
-const __require = createRequire(__filename);
-
-// Install every globalThis/prototype polyfill that doesn't depend on loading the
-// ESM side-effect modules (worker-polyfill, navigator-locks). Synchronous and
-// idempotent — safe to call once per realm. `preloaded` carries the CJS-required
-// polyfill packages the preload entry stashed (urlpattern, float16), since the
-// resolve hook would otherwise clobber a later import of them.
-function installSyncPolyfills(preloaded) {
-  preloaded = preloaded || {};
-
-  // ── Web Storage: neutralize the throwing localStorage getter ────────
-  // When nub injects `--experimental-webstorage` on the 22.4–24 band AND the user
-  // did NOT pass `--localstorage-file`, Node installs a `localStorage` global that
-  // is a getter THROWING `ERR_INVALID_ARG_VALUE` on ANY access — even
-  // `typeof localStorage` throws, so feature-detection is impossible and the throw
-  // can surface before user code expects it. The spawn layer signals this case via
-  // the internal `__NUB_NEUTRALIZE_LOCALSTORAGE` env var (set iff unflagged ∧
-  // no user file). Replace the throwing getter with a plain `undefined` value —
-  // matching Node 25+'s clean shape — so `typeof localStorage === "undefined"` is
-  // true and no throw occurs; `sessionStorage`, which needs only the flag, keeps
-  // working. This runs in the preload BEFORE any user code, so the throwing getter
-  // is never observed. When the user passes `--localstorage-file`, the env var is
-  // absent and `localStorage` works normally (we do not touch it). We deliberately
-  // KEEP the env var set so it inherits to the whole process subtree: a `node`- or
-  // `nub`-spawned grandchild re-inherits the webstorage flag via NODE_OPTIONS and
-  // would otherwise re-install the throwing getter with no neutralize signal. It's
-  // an internal `__NUB_*` plumbing var that's explicitly fine to leak to children.
-  // Neutralization is idempotent — a descendant re-running this preload with the
-  // var still set just re-defines `localStorage` to undefined again, which is
-  // harmless. The descriptor is configurable+writable so user code can still assign
-  // its own `localStorage`.
-  if (process.env.__NUB_NEUTRALIZE_LOCALSTORAGE) {
-    try {
-      Object.defineProperty(globalThis, "localStorage", {
-        value: undefined,
-        configurable: true,
-        writable: true,
-        enumerable: false,
-      });
-    } catch { /* descriptor non-configurable on this runtime: leave Node's behavior */ }
-  }
-
-  // ── reportError (WinterTC min-common-API, not in any Node) ──────────
-  // Defined NON-ENUMERABLE so it is invisible to `Object.keys(globalThis)` /
-  // for-in / structured-clone-of-keys — that invisibility-to-enumeration IS the
-  // additive contract: code written for vanilla Node must not observe nub's
-  // injected globals when it enumerates the global object. Node defines its own
-  // globals non-enumerably for the same reason. Kept writable+configurable so
-  // user code can still override or delete it, matching Node's global descriptors.
-  if (typeof globalThis.reportError !== "function") {
-    Object.defineProperty(globalThis, "reportError", {
-      value: (err) => {
-        queueMicrotask(() => {
-          throw err;
-        });
-      },
-      enumerable: false,
-      writable: true,
-      configurable: true,
-    });
-  }
-
-  // ── File (global on Node 20+, missing on the 18.x compat floor) ─────
-  // Node exposes the WHATWG `File` as a global from Node 20; on 18.13–18.x it
-  // exists only as `node:buffer`'s `File` export. Backfill the global from there
-  // so worker/messaging code that constructs `new File(...)` works down to the
-  // floor (polyfill-all-the-way-down). Identity is preserved (same constructor as
-  // `node:buffer`), so `instanceof` and undici's webidl brand checks hold. Blob is
-  // already global on 18.x, but the same backfill guards it for completeness.
-  // Non-enumerable to match Node's own global descriptors (the additive contract:
-  // invisible to global enumeration).
-  //
-  // Node 18 emits a one-time `ExperimentalWarning: buffer.File …` on the FIRST
-  // `new File(...)` (the constructor, NOT the property read). Without nub the floor
-  // simply has no `File` global, so backfilling it would newly surface that warning
-  // when user code first constructs a File. To keep the floor backfill silent we
-  // force one throwaway construction INSIDE a suppression window: that consumes
-  // Node's once-per-feature guard (the warning is dropped here) so the user's later
-  // `new File(...)` is silent.
-  if (typeof globalThis.File === "undefined" || typeof globalThis.Blob === "undefined") {
-    const origEmitWarning = process.emitWarning;
-    process.emitWarning = function (warning, ...rest) {
-      const opt = rest[0];
-      const type = opt && typeof opt === "object" ? opt.type : opt;
-      const msg = typeof warning === "string" ? warning : (warning && warning.message) || "";
-      if (type === "ExperimentalWarning" && /buffer\.(File|Blob)/.test(msg)) return;
-      return origEmitWarning.call(this, warning, ...rest);
-    };
-    try {
-      const buffer = require("node:buffer");
-      const sampleArgs = { File: [[], ""], Blob: [[]] };
-      for (const name of ["File", "Blob"]) {
-        const Ctor = buffer[name];
-        if (typeof globalThis[name] === "undefined" && typeof Ctor === "function") {
-          Object.defineProperty(globalThis, name, {
-            value: Ctor,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-          });
-          // Trip (and suppress) the experimental-feature warning now, so user code
-          // never sees it.
-          try { new Ctor(...sampleArgs[name]); } catch { /* construction shape varies; the warning fires regardless */ }
-        }
-      }
-    } finally {
-      process.emitWarning = origEmitWarning;
-    }
-  }
-
-  // ── MessageEvent.ports → frozen array (WHATWG read-only requirement) ─
-  // The spec mandates `MessageEvent.ports` be a read-only (frozen) array; Node's
-  // native MessageEvent returns a mutable array. Wrap the configurable prototype
-  // getter so every read yields a frozen array, for both a native MessageChannel's
-  // delivery and nub's worker-side MessageEvents. Idempotent (the wrapper is marked
-  // so a re-run in the same realm doesn't double-wrap).
-  if (typeof globalThis.MessageEvent === "function") {
-    const proto = globalThis.MessageEvent.prototype;
-    const desc = Object.getOwnPropertyDescriptor(proto, "ports");
-    if (desc && typeof desc.get === "function" && desc.configurable && !desc.get.__nubFreezesPorts) {
-      const origGet = desc.get;
-      const get = function () {
-        const ports = origGet.call(this);
-        return Array.isArray(ports) ? Object.freeze(ports) : ports;
-      };
-      get.__nubFreezesPorts = true;
-      Object.defineProperty(proto, "ports", { ...desc, get });
-    }
-  }
-
-  // ── URLPattern (native on Node 24+, missing on 22.x) ───────────────
-  if (typeof globalThis.URLPattern === "undefined") {
-    const mod = preloaded.urlpattern;
-    const URLPattern = mod?.URLPattern;
-    if (URLPattern) globalThis.URLPattern = URLPattern;
-  }
-
-  // Temporal (in no Node version) is installed as a LAZY global by the preload
-  // entry after this runs — see preload.cjs / 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 the preload entry). 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 = preloaded.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;
-      }
-    }
-  }
-}
-
-// Load the two ESM side-effect modules — Web Locks (navigator.locks) and the
-// browser-shape Worker global — synchronously via `require()`. Valid on the fast
-// tier ONLY (Node 22.15+), where require(esm) of these side-effecting ES modules
-// works (verified). The compat tier must NOT call this; it loads them with
-// dynamic `import()` from preload.mjs instead.
-function installEsmPolyfillsSync() {
-  // ── navigator.locks (native on Node 24+, missing on 22.x) ──────────
-  if (typeof globalThis.navigator?.locks === "undefined") {
-    __require("./navigator-locks.mjs");
-  }
-  // ── Worker (browser-shape global, not in any Node) ──────────────────
-  __require("./worker-polyfill.mjs");
-}
-
-module.exports = { installSyncPolyfills, installEsmPolyfillsSync };

package/runtime/preload-async-hooks.mjs

@@ -1,110 +0,0 @@
-// Nub compat-tier hooks module — Node 18.19 through 22.14.
-//
-// On Node 22.15+, runtime/preload.mjs registers its hooks synchronously via
-// `module.registerHooks({ resolve, load })`. That API didn't exist before 22.15,
-// so on 18.19..22.14 the main-thread bootstrap calls
-// `module.register('./preload-async-hooks.mjs', parentURL)` instead, which loads
-// THIS file into a dedicated loader worker thread and uses its async
-// `resolve` / `load` exports. (CommonJS `require()` is augmented separately, on
-// the main thread, by preload.mjs's installCjsRequireHooks — `module.register`
-// hooks the ESM loader only.)
-//
-// There is NO logic of its own here: resolution + transpilation come verbatim
-// from runtime/transform-core.mjs, the single source of truth shared with the
-// fast path. The two tiers can no longer drift — the only difference is the
-// async function signatures Node's loader-worker protocol requires (it awaits
-// the returned values, so returning the core's synchronous results is fine). The
-// worker injects no watch hooks (watch IPC is main-thread only), so the core's
-// dependency reporters stay no-ops here, exactly as before the extraction.
-
-// Floor bootstrap (Node < 22.3/20.16/18.20.4): threads node:module's createRequire
-// into transform-core via a MODULE-SCOPE SETTER — never globalThis (brand boundary) —
-// because transform-core has no process.getBuiltinModule on the floor. floor-builtin
-// calls transform-core's setter during its own evaluation, so importing it FIRST
-// (ESM evaluates imports in source order) means the value is threaded before any hook
-// in this loader worker fires. No-op where getBuiltinModule exists. This worker runs
-// OFF any user loader chain, so floor-builtin's static node:module import never leaks
-// — see floor-builtin.mjs. (worker-polyfill is NOT loaded here: this is the dedicated
-// loader worker, not a user realm, so it installs no browser globals.)
-import "./floor-builtin.mjs";
-import {
-  TRANSPILE_EXTS, PLAIN_JS_EXTS, DATA_EXTS,
-  extname, resolveSpec, loadTranspile, maybeTranspilePlainJs, loadData, isNodeModules,
-} from "./transform-core.mjs";
-import { createRequire, isBuiltin } from "node:module";
-import { existsSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { pnpResolveEsm } from "./pnp-util.cjs";
-
-// Yarn PnP handle for this loader worker. The worker runs in its own thread where
-// `.pnp.cjs` was never --require'd, so neither the `pnpapi` builtin nor
-// `module.findPnpApi` is installed here (the main-thread preload uses findPnpApi; it
-// can't reach across to this realm). So bootstrap PnP for this thread directly: walk
-// up from cwd to the `.pnp.cjs` Rust located and require it by absolute path — that
-// returns the pnpapi object. nub then resolves PnP specifiers via
-// `pnpapi.resolveRequest` (its public, conditions-free resolver), mirroring the main
-// thread, so there is no need to register Yarn's `.pnp.loader.mjs` (which deadlocks
-// against the fast tier's `module.registerHooks`). `null` when not a PnP run.
-const __pnp = (() => {
-  if (!process.versions.pnp) return null;
-  const req = createRequire(import.meta.url);
-  try {
-    let dir = process.cwd();
-    for (;;) {
-      const candidate = join(dir, ".pnp.cjs");
-      if (existsSync(candidate)) return req(candidate);
-      const parent = dirname(dir);
-      if (parent === dir) return null;
-      dir = parent;
-    }
-  } catch { return null; }
-})();
-
-// Node calls this once per worker when the main thread invokes
-// `module.register(url, parentURL, { data })`. We accept and ignore the payload
-// so future main-thread → worker plumbing is non-breaking. Returning a Promise
-// lets the main thread `await register(...)`.
-export async function initialize(_data) {}
-
-// ── Resolve hook ────────────────────────────────────────────────────
-export async function resolve(specifier, context, nextResolve) {
-  const r = resolveSpec(specifier, context.parentURL);
-  if (r) return r;
-  // Yarn PnP: resolve deps through PnP's own resolver — identical to the fast tier,
-  // via the shared helper (resolveRequest with the import conditions + format
-  // detection), so dual packages resolve to their `import` build.
-  if (__pnp && !isBuiltin(specifier) && !specifier.startsWith("node:")) {
-    try {
-      const res = pnpResolveEsm(__pnp, specifier, context);
-      if (res) return res;
-    } catch { /* fall through to Node's resolver */ }
-  }
-  return nextResolve(specifier, context);
-}
-
-// ── Load hook ───────────────────────────────────────────────────────
-export async function load(url, context, nextLoad) {
-  const ext = extname(url);
-  // node_modules deps are NEVER transpiled (the byte-parity boundary). This guard is
-  // make-or-break now that TRANSPILE_EXTS includes `.js`/`.mjs`/`.cjs`: without it,
-  // the compat tier would route every dependency `.js` through oxc. (loadTranspile's
-  // own skip-gate handles the project-source no-op case; this keeps deps off the
-  // pipeline entirely.) Mirrors the fast-tier sync hook's `!isNodeModules` gate.
-  if (TRANSPILE_EXTS.has(ext) && !isNodeModules(url)) {
-    // Module-format + decorator detection inside loadTranspile is a synchronous
-    // native call (nub's addon), available on every supported Node — no parser
-    // warm-up needed (the old `await ensureParser()` for the ESM-only oxc-parser
-    // is gone with the package).
-    return loadTranspile(url, ext);
-  }
-  // Project-source plain JS: transpile ONLY when it carries transformable syntax. A
-  // no-op plain-JS file returns null and falls through to `nextLoad` — Node's own
-  // loader handles it byte-identically, preserving every native CJS/ESM behavior.
-  // node_modules excluded (the byte-parity boundary).
-  if (PLAIN_JS_EXTS.has(ext) && !isNodeModules(url)) {
-    const r = maybeTranspilePlainJs(url, ext);
-    if (r) return r;
-  }
-  if (ext in DATA_EXTS) return loadData(url, ext);
-  return nextLoad(url, context);
-}