@nubjs/nub-linux-arm64 0.0.5 → 0.0.8

package/runtime/polyfills.mjs

@@ -26,19 +26,59 @@ if (typeof globalThis.URLPattern === "undefined") {
   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;
-}
+// Temporal (in no Node version) is installed as a LAZY global by the main
+// preload after this module runs — see preload.mjs (A37). Touching
+// globalThis.Temporal here would defeat that laziness, so we must not.
 
 // ── Stage 4 polyfills (native on Node 24+, missing on 22.x) ────────
 
-// RegExp.escape
+// 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 escapeRe = /[\\^$.*+?()[\]{}|]/g;
-  RegExp.escape = (s) => String(s).replace(escapeRe, "\\$&");
+  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)
@@ -56,98 +96,34 @@ if (typeof Promise.try !== "function") {
   };
 }
 
-// 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).
+// Float16Array (TC39 Stage 4, native on Node 24+; absent on our 22.x floor).
+// Installed from the spec-compliant @petamoriken/float16 polyfill (vendored,
+// preloaded by preload.mjs). It provides the full TypedArray method surface
+// (map/filter/subarray/set/reduce/…) and correct round-to-nearest-even,
+// including subnormals — unlike the prior hand-rolled Proxy shim, which had
+// ~30 methods missing and truncating/denormal-flushing conversion.
+//
+// INHERENT userland limitation (not fixable by any JS polyfill): a polyfilled
+// Float16Array isn't recognized by `ArrayBuffer.isView()` (it has no V8 internal
+// [[TypedArrayName]] slot). Code needing that check should use the polyfill's
+// `isFloat16Array`. See wiki/runtime/float16array-polyfill.md.
 if (typeof globalThis.Float16Array === "undefined") {
-  const 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];
+  const f16 = globalThis.__nubPreloaded?.float16;
+  if (f16?.Float16Array) {
+    globalThis.Float16Array = f16.Float16Array;
+
+    if (typeof DataView.prototype.getFloat16 !== "function") {
+      DataView.prototype.getFloat16 = function (offset, littleEndian) {
+        return f16.getFloat16(this, offset, littleEndian);
+      };
+      DataView.prototype.setFloat16 = function (offset, value, littleEndian) {
+        f16.setFloat16(this, offset, value, littleEndian);
+      };
     }
-    if (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);
-        },
-      });
+    if (typeof Math.f16round !== "function") {
+      Math.f16round = f16.f16round;
     }
-    [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));
   }
 }
 

package/runtime/preload-async-hooks.mjs

@@ -0,0 +1,50 @@
+// 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.
+
+import {
+  TRANSPILE_EXTS, DATA_EXTS,
+  extname, resolveSpec, loadTranspile, loadData, ensureParser,
+} from "./transform-core.mjs";
+
+// 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);
+  return r ?? nextResolve(specifier, context);
+}
+
+// ── Load hook ───────────────────────────────────────────────────────
+export async function load(url, context, nextLoad) {
+  const ext = extname(url);
+  if (TRANSPILE_EXTS.has(ext)) {
+    // Ensure oxc-parser is loaded (via dynamic import — `require` of this
+    // ESM-only package fails below require(esm) on Node 18.19 / 20.x). The async
+    // load hook can await; the synchronous module-format + decorator detection
+    // inside loadTranspile then has the parser.
+    await ensureParser();
+    return loadTranspile(url, ext);
+  }
+  if (ext in DATA_EXTS) return loadData(url, ext);
+  return nextLoad(url, context);
+}