@nubjs/nub-win32-arm64 0.0.42 → 0.0.44

package/package.json

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

package/runtime/preload-common.cjs

@@ -159,6 +159,44 @@ function installUserHookDetector() {
   try { module_.registerHooks = wrapped; } catch {}
 }
 
+// ── Internal `module.register()` without the DEP0205 leak ────────────
+// `module.register()` is the loader-WORKER registration surface (async ESM hooks in
+// a dedicated thread). nub uses it for the compat tier (18.19–22.14, where the sync
+// `module.registerHooks` doesn't exist) and for the fast tier's
+// `--no-experimental-require-module` fallback (where `require(esm)` is off, so the
+// in-thread sync hooks can't load transform-core.mjs synchronously). On Node 26+,
+// `module.register()` emits a one-shot `[DEP0205]` DeprecationWarning steering callers
+// to `module.registerHooks()` — but nub CANNOT use `registerHooks` on these paths
+// (no sync surface on compat; no sync core load when require(esm) is disabled), and
+// the deprecation is for nub's OWN internal call, not anything the user wrote: the
+// user has no action to take, so the warning is pure noise on their stderr. Suppress
+// exactly that DEP0205 emission for the duration of nub's own register() call, then
+// restore `process.emitWarning` untouched, so a user's later `module.register()` (or
+// any other deprecation) still warns normally. Default-preserving: only nub's
+// internal call is silenced, only for DEP0205, only on the versions that emit it.
+function registerLoaderWorker(specifier, parentURL, options) {
+  const realEmitWarning = process.emitWarning;
+  let restored = false;
+  const restore = () => {
+    if (restored) return;
+    restored = true;
+    try { process.emitWarning = realEmitWarning; } catch {}
+  };
+  try {
+    process.emitWarning = function (warning, ...rest) {
+      // Node calls emitWarning(msg, 'DeprecationWarning', 'DEP0205', ...) for the
+      // module.register() deprecation. Swallow only that exact code; pass everything
+      // else (including any non-DEP0205 deprecation) straight through.
+      const code = typeof rest[0] === "object" && rest[0] !== null ? rest[0].code : rest[1];
+      if (code === "DEP0205") return;
+      return realEmitWarning.call(this, warning, ...rest);
+    };
+    return module_.register(specifier, parentURL, options);
+  } finally {
+    restore();
+  }
+}
+
 function makeHooks(core, watchReporting) {
   installUserHookDetector();
 
@@ -763,6 +801,7 @@ function reenableUserCompileCache() {
 
 module.exports = {
   installWatchReporting,
+  registerLoaderWorker,
   makeHooks,
   installCjsRequireHooks,
   preloadPolyfillPackages,

package/runtime/preload.cjs

@@ -143,7 +143,11 @@ if (!requireEsmDisabled) {
   // through the registered loader-worker hooks. User require(esm) of THEIR own ES
   // modules still gets Node's native ERR_REQUIRE_ESM, exactly as the flag promises.
   const { pathToFileURL } = require("node:url");
-  module_.register("./preload-async-hooks.mjs", pathToFileURL(__filename).href);
+  // Via the shared helper so Node 26+'s DEP0205 (steering to module.registerHooks) is
+  // not leaked onto the user's stderr — nub is forced onto module.register here
+  // because require(esm) is off, so registerHooks' in-thread sync core load is
+  // impossible; the user has no action to take. See registerLoaderWorker.
+  common.registerLoaderWorker("./preload-async-hooks.mjs", pathToFileURL(__filename).href);
 
   // Sync, non-require(esm) polyfills still install (none of them require(esm)).
   // Clobbered-polyfill packages are CJS requires, unaffected by the flag.

package/runtime/preload.mjs

@@ -80,7 +80,11 @@ if (__isFastTier) {
   // Compat path: ESM `import` hooks run in a dedicated loader worker thread. That
   // worker resolves PnP deps via pnpapi.resolveRequest itself (preload-async-
   // hooks.mjs), so no Yarn `.pnp.loader.mjs` registration is needed here either.
-  module.register("./preload-async-hooks.mjs", import.meta.url);
+  // Via the shared helper so any DEP0205 from nub's own register() call (Node 26+,
+  // if this compat path is ever reached there) is not leaked onto the user's stderr.
+  // On the compat tier proper (18.19–22.14) registerHooks doesn't exist, so the
+  // loader-worker is the only hook surface; the user has no action to take.
+  common.registerLoaderWorker("./preload-async-hooks.mjs", import.meta.url);
   // (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.)

package/runtime/version.mjs

@@ -9,4 +9,4 @@
 // previously lived as a literal inside preload.mjs, which `make version` patched,
 // while the worker carried a hand-maintained "…-compat" copy that `make version`
 // never touched — a latent staleness bug this module closes.)
-export const NUB_VERSION = "0.0.42";
+export const NUB_VERSION = "0.0.44";