@nubjs/nub-win32-arm64 0.0.14 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nubjs/nub-win32-arm64",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "Nub binary for win32-arm64",
   "license": "MIT",
   "repository": "https://github.com/nub-js/nub",

package/runtime/preload-async-hooks.mjs

@@ -19,7 +19,7 @@
 
 import {
   TRANSPILE_EXTS, DATA_EXTS,
-  extname, resolveSpec, loadTranspile, loadData, ensureParser,
+  extname, resolveSpec, loadTranspile, loadData,
 } from "./transform-core.mjs";
 
 // Node calls this once per worker when the main thread invokes
@@ -38,11 +38,10 @@ export async function resolve(specifier, context, nextResolve) {
 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();
+    // 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);
   }
   if (ext in DATA_EXTS) return loadData(url, ext);

package/runtime/preload.cjs

@@ -102,14 +102,18 @@ if (!requireEsmDisabled) {
   // ── Hook registration (fast tier: sync, in-thread) ────────────────
   // Same realm as user code; covers `import` and (Node 24+) `require`.
   // registerHooks' require RESOLUTION is incomplete on 22.15–24, so also install
-  // the main-thread CJS resolve shim. Install the classic require.extensions
-  // transpile shim only on 22.15–22.17 (no native `.ts`); on 22.18+/24+ skip it so
-  // Node's native require() of `.ts` — incl. ES modules — isn't shadowed (see
-  // installCjsRequireHooks).
-  const __hasNativeTs = !!process.features?.typescript;
+  // the main-thread CJS resolve shim (its _resolveFilename half, always on). We do
+  // NOT install the classic require.extensions transpile shim on the fast tier: the
+  // sync registerHooks LOAD hook already transpiles require()'d `.ts` (CJS content,
+  // tsconfig paths, .tsx, extensionless — all verified), and native require(esm)
+  // (>= 22.12, always present at the 22.15+ fast floor) loads ES-module `.ts`. The
+  // classic require.extensions['.ts'] hook would SHADOW that native require(esm) and
+  // throw a bogus ERR_REQUIRE_ESM on every ESM `.ts` entry on 22.15–22.17 (where
+  // process.features.typescript is still false) — so it must stay off here. On
+  // 22.18+/24+ this was already the behavior (native-TS → false); now it's uniform.
   const { resolve, load } = common.makeHooks(core, watchReporting);
   module_.registerHooks({ resolve, load });
-  common.installCjsRequireHooks(core, !__hasNativeTs);
+  common.installCjsRequireHooks(core, false);
 
   // ── Sync polyfills + lazy ESM-side-effect polyfills ───────────────
   installSyncPolyfills(__preloadedPolyfills);

package/runtime/preload.mjs

@@ -9,10 +9,11 @@
 //
 // THIS file stays the compat path: on 18.19–22.14, `module.registerHooks` does not
 // exist and `require(esm)` is unreliable, so hooks run async in a dedicated loader
-// worker via `module.register`, and the parser is preloaded via dynamic `import()`
-// while we can still `await`. That async machinery is exactly why the compat tier
-// keeps `--import` — its top-level `await` is accepted here (an `--import` ESM
-// module may be async), and the < 22.15 floor has no equivalent sync surface.
+// worker via `module.register`. That async machinery is why the compat tier keeps
+// `--import` — its top-level `await` is accepted here (an `--import` ESM module may
+// be async), and the < 22.15 floor has no equivalent sync surface. (Module-format
+// + decorator detection no longer needs a preloaded JS parser: it is a synchronous
+// native addon call, so there is nothing to `await`-warm-up before hooks run.)
 //
 // Resolution + transpile primitives come from runtime/transform-core.mjs; the
 // non-tier-specific wiring (watch IPC, the CJS require() shim, clobbered-polyfill
@@ -56,19 +57,29 @@ common.installWatchReporting(core);
 if (__isFastTier) {
   // Defensive only — the Rust path uses preload.cjs for 22.15+. If reached, the
   // sync registerHooks API is available; register synchronously to stay correct.
+  // Match preload.cjs: NO classic require.extensions shim on the fast tier — the
+  // sync registerHooks load hook + native require(esm) cover require()'d `.ts`
+  // (incl. ES modules); the classic shim would shadow require(esm) and throw a
+  // bogus ERR_REQUIRE_ESM on 22.15–22.17.
   const { resolve, load } = common.makeHooks(core, process.env.WATCH_REPORT_DEPENDENCIES === "1");
   module.registerHooks({ resolve, load });
-  common.installCjsRequireHooks(core, !__hasNativeTs);
+  common.installCjsRequireHooks(core, false);
 } else if (__isCompatTier) {
   // Compat path: ESM `import` hooks run in a dedicated loader worker thread.
   module.register("./preload-async-hooks.mjs", import.meta.url);
-  // The main-thread CommonJS require() shim's format detection is synchronous and
-  // reaches down to Node 18.19, where `require("oxc-parser")` (ESM-only) fails — so
-  // preload the parser via dynamic import now, while we can still await.
-  await core.ensureParser();
+  // (The main-thread require() shim's module-format + decorator detection is a
+  // synchronous native addon call now — no parser warm-up; the old
+  // `await core.ensureParser()` for the ESM-only oxc-parser is gone.)
   // module.register() is ESM-loader-only; augment CommonJS require() on the main
-  // thread too. The compat tier never has native `.ts`, so it always installs the
-  // classic transpile shim (CJS transpile + clean error for ES-module require()).
+  // thread too. The compat tier has no sync registerHooks, so require()'d `.ts`
+  // MUST be transpiled by the classic require.extensions shim — hence it always
+  // installs (true). KNOWN LIMITATION: on the require(esm)-capable slice of the
+  // compat tier (22.12–22.14) an explicit `require('./esm-module.ts')` still
+  // surfaces ERR_REQUIRE_ESM, because the classic shim shadows native require(esm)
+  // and can't delegate to it from inside `_compile`. ESM `.ts` ENTRIES and `import`
+  // of ESM `.ts` both work (they ride the ESM loader); only require()-of-ESM-`.ts`
+  // is affected — an uncommon pattern. Below 22.12 the error is fully correct
+  // (no require(esm) at all). Fast tier (22.15+) has none of this — see preload.cjs.
   common.installCjsRequireHooks(core, !__hasNativeTs);
 } else {
   process.stderr.write(