@nubjs/nub-win32-x64 0.0.5 → 0.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nubjs/nub-win32-x64",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Nub binary for win32-x64",
   "license": "MIT",
   "repository": "https://github.com/colinhacks/nub",

package/runtime/cache-evict.mjs

@@ -0,0 +1,69 @@
+// Bounded-size eviction for the transpile cache (A16). Kept in its own module
+// so it loads lazily — only when a sweep is actually due (see preload.mjs's
+// throttled maybeSweepCache) — and so it can be tested in isolation.
+//
+// LRU by mtime: when the cache exceeds `maxBytes`, delete oldest-written entries
+// until at or below `lowWater`. Entries are content-addressed, so evicting one
+// only costs a re-transpile on next use. mtime reflects write time, not last
+// read — true read-LRU would need an mtime touch on every cache hit, defeating
+// the read-only fast path; oldest-written is the right, cheap proxy for a cache
+// whose entries are written once per source version.
+
+import { readdirSync, statSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+
+// A valid cache entry is a 64-char lowercase-hex sha256 (see cacheKey in
+// preload.mjs). Everything else — the `.sweep` sentinel, `*.tmp` in-flight
+// writes from cacheSet — is skipped: never counted toward the cap, never
+// evicted.
+const ENTRY_RE = /^[0-9a-f]{64}$/;
+
+/**
+ * Evict oldest entries from `dir` until total entry bytes ≤ `lowWater`, if they
+ * exceed `maxBytes`. Returns `{ scanned, deleted, freed }`. Best-effort: a stat
+ * or unlink that fails (concurrent reader/evictor, Windows open handle) is
+ * skipped, and the next sweep retries. Never throws.
+ */
+export function sweepCache(dir, maxBytes, lowWater = Math.floor(maxBytes * 0.75)) {
+  let names;
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return { scanned: 0, deleted: 0, freed: 0 };
+  }
+
+  const entries = [];
+  let total = 0;
+  for (const name of names) {
+    if (!ENTRY_RE.test(name)) continue;
+    const path = join(dir, name);
+    const s = statSync(path, { throwIfNoEntry: false });
+    if (!s || !s.isFile()) continue;
+    entries.push({ path, size: s.size, mtime: s.mtimeMs });
+    total += s.size;
+  }
+
+  if (total <= maxBytes) {
+    return { scanned: entries.length, deleted: 0, freed: 0 };
+  }
+
+  // Oldest first; delete down to the low-water mark so we don't sweep again on
+  // the very next write.
+  entries.sort((a, b) => a.mtime - b.mtime);
+  let deleted = 0;
+  let freed = 0;
+  for (const e of entries) {
+    if (total <= lowWater) break;
+    try {
+      unlinkSync(e.path);
+      total -= e.size;
+      freed += e.size;
+      deleted++;
+    } catch {
+      // Already removed by a concurrent sweep, or held open (Windows): skip.
+      // `total` is unchanged so we keep trying to reach lowWater via other
+      // entries; the loop is bounded by `entries`, so it still terminates.
+    }
+  }
+  return { scanned: entries.length, deleted, freed };
+}

package/runtime/node_modules/@oxc-parser/binding-win32-x64-msvc/README.md

@@ -0,0 +1,3 @@
+# `@oxc-parser/binding-win32-x64-msvc`
+
+This is the **x86_64-pc-windows-msvc** binary for `@oxc-parser/binding`

package/runtime/node_modules/@oxc-parser/binding-win32-x64-msvc/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@oxc-parser/binding-win32-x64-msvc",
+  "version": "0.132.0",
+  "cpu": [
+    "x64"
+  ],
+  "main": "parser.win32-x64-msvc.node",
+  "files": [
+    "parser.win32-x64-msvc.node"
+  ],
+  "description": "Oxc Parser Node API",
+  "keywords": [
+    "ast",
+    "estree",
+    "javascript",
+    "oxc",
+    "parser",
+    "typescript"
+  ],
+  "author": "Boshen and oxc contributors",
+  "homepage": "https://oxc.rs/docs/guide/usage/parser",
+  "license": "MIT",
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oxc-project/oxc.git",
+    "directory": "napi/parser"
+  },
+  "bugs": "https://github.com/oxc-project/oxc/issues",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "os": [
+    "win32"
+  ]
+}

package/runtime/node_modules/@oxc-transform/binding-win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oxc-transform/binding-win32-x64-msvc",
-  "version": "0.133.0",
+  "version": "0.132.0",
   "cpu": [
     "x64"
   ],

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