@nubjs/nub-win32-x64 0.0.20 → 0.0.21

package/package.json

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

package/runtime/pnp-util.cjs

@@ -1,51 +1,62 @@
-// Shared Yarn PnP ESM-resolution helper, used by BOTH realms that resolve modules:
-// the main-thread preload (preload-common.cjs, fast tier) and the compat-tier
-// loader worker (preload-async-hooks.mjs). Both resolve PnP specifiers identically
-// — through PnP's public, conditions-free `resolveRequest` — and both must hand
-// Node an explicit module `format`, so the logic lives here once rather than being
-// copy-pasted across two threads where it could drift.
-//
-// Why the explicit format: without it, Node <= 20.11 mis-detects a zip-stored `.js`
-// file from a `"type":"module"` package as CommonJS, routes it through the CJS
-// translator, and `require()`s the ESM source -> ERR_REQUIRE_ESM. Newer Node gets
-// it right on its own; emitting the format makes PnP ESM deps work down to the
-// 18.19 floor. (CJS resolution stays in preload-common.cjs's `_resolveFilename`
-// branch — it returns a path, not a hook result, and is main-thread-only.)
+// 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 { join, sep } = require("node:path");
+const { dirname, join, sep } = require("node:path");
 const { fileURLToPath, pathToFileURL } = require("node:url");
 
-// A directory issuer for pnpapi.resolveRequest: cwd with a trailing separator so
-// PnP treats it as a directory. `path.sep` (not a literal "/") keeps it correct on
-// Windows, where cwd uses backslashes and a mixed "C:\x/" can confuse resolution.
+// 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 PnP-resolved file. `.mjs`/`.cjs` are unambiguous; a `.js` file
-// inherits its package's `type` (read via PnP — `fs` is zip-patched in both realms).
-// `null` lets Node decide (non-JS, or detection failed).
-function pnpFormat(pnp, resolvedPath) {
+// 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";
-  if (!resolvedPath.endsWith(".js")) return null;
-  try {
-    const info = pnp.getPackageInformation(pnp.findPackageLocator(resolvedPath));
-    const pj = JSON.parse(readFileSync(join(info.packageLocation, "package.json"), "utf8"));
-    return pj.type === "module" ? "module" : "commonjs";
-  } catch {
-    return null;
+  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 an ESM `specifier` (from `parentURL`) through PnP and return a Node
-// resolve-hook result `{ url, format?, shortCircuit }`, or `null` if PnP can't
-// resolve it (then the caller delegates to Node's default resolver). Throwing is
-// the caller's signal to fall through too — callers wrap in try/catch.
-function pnpResolveEsm(pnp, specifier, parentURL) {
+// 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();
-  const resolved = pnp.resolveRequest(specifier, issuer);
+  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;
-  const format = pnpFormat(pnp, resolved);
-  return { url: pathToFileURL(resolved).href, shortCircuit: true, ...(format && { format }) };
+  return { url: pathToFileURL(resolved).href, format: formatOf(resolved), shortCircuit: true };
 }
 
 module.exports = { pnpResolveEsm, cwdIssuer };

package/runtime/preload-async-hooks.mjs

@@ -61,10 +61,11 @@ 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 + module-format detection).
+  // 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.parentURL);
+      const res = pnpResolveEsm(__pnp, specifier, context);
       if (res) return res;
     } catch { /* fall through to Node's resolver */ }
   }

package/runtime/preload-common.cjs

@@ -142,19 +142,17 @@ function makeHooks(core, watchReporting) {
   function resolve(specifier, context, nextResolve) {
     const r = core.resolveSpec(specifier, context.parentURL);
     if (r) return r;
-    // Under Yarn PnP, delegating to `nextResolve` flows into Node's default
-    // resolution, which calls PnP's patched `_resolveFilename` WITH a `conditions`
-    // option PnP rejects once a customization hook is registered ("aren't supported
-    // by PnP yet (conditions)"). PnP exposes its own conditions-free resolver —
-    // `pnpapi.resolveRequest` — so resolve through THAT and hand Node the file URL.
-    // Still "PnP does the resolution" (its public API); nub adds none of its own.
-    // Returns a virtual `.zip` path for zip-stored deps, which Node reads via the
-    // zipfs patch `.pnp.cjs` installed. Falls back to `nextResolve` if PnP can't
-    // resolve (e.g. a builtin or a relative path PnP defers to Node).
+    // Yarn PnP (ESM): PnP doesn't patch the ESM loader, so `import` of a PnP dep must
+    // be resolved explicitly — through `pnpapi.resolveRequest`, passing Node's
+    // `context.conditions` (the import-side set) so a DUAL package resolves to its
+    // `import` build, not its `require` build. Returns a virtual `.zip` path Node
+    // reads via the zipfs patch. If the api is momentarily unavailable we fall through
+    // to `nextResolve`, which reaches nub's `_resolveFilename` override (delegating to
+    // PnP) — so a plain dep still resolves; only a dual package's condition is lost.
     const pnp = pnpApi();
     if (pnp && !module_.isBuiltin(specifier) && !specifier.startsWith("node:")) {
       try {
-        const res = pnpResolveEsm(pnp, specifier, context && context.parentURL);
+        const res = pnpResolveEsm(pnp, specifier, context);
         if (res) return res;
       } catch { /* fall through to Node's resolver */ }
     }
@@ -302,46 +300,35 @@ function installCjsRequireHooks(core, withClassicTranspile) {
       }
       return resolved;
     }
-    // Yarn PnP, FAST TIER ONLY. On the fast tier nub registers a sync
-    // `module.registerHooks` resolve hook, which makes Node thread a `conditions`
-    // option into PnP's patched `_resolveFilename` ("aren't supported by PnP yet
-    // (conditions)") AND re-inject it even if we pass none — so we must resolve
-    // everything ourselves via PnP's conditions-free `pnpapi.resolveRequest` and the
-    // native path primitives, never falling through to PnP's `_resolveFilename`. On
-    // the COMPAT tier there is no sync hook, so PnP's own `_resolveFilename` resolves
-    // CJS deps fine (no conditions option) and interposing here instead recurses to
-    // OOM on the Node 18 line — so the PnP branch is gated to where registerHooks
-    // exists. `pnpApi()` is null off-PnP, making this doubly safe.
-    // On a PnP tree + fast tier (sync `registerHooks` registered), resolve through
-    // PnP's conditions-free `resolveRequest` and NEVER fall through to
-    // `origResolveFilename` — that is PnP's patched `_resolveFilename`, which rejects
-    // the `conditions` option Node injects under a registered hook. The gate is
-    // `process.versions.pnp` (set the moment `.pnp.cjs` runs), NOT a non-null api:
-    // if `findPnpApi` momentarily misses we still avoid PnP's resolver and use Node's
-    // native `_findPath`, so a transient lookup miss can't leak a `conditions` crash.
-    const inPnp = typeof module_.registerHooks === "function" && !!process.versions.pnp;
-    if (inPnp) {
-      if (module_.isBuiltin(request)) return request; // PnP defers builtins to Node
-      const pnp = pnpApi();
-      if (pnp) {
-        try {
-          const issuer = parent && typeof parent.filename === "string" ? parent.filename : cwdIssuer();
-          const r = pnp.resolveRequest(request, issuer);
-          if (r) return r;
-        } catch { /* fall through to native path resolution below */ }
+    // Yarn PnP (CJS): `.pnp.cjs` already patched THIS function (origResolveFilename)
+    // to resolve from PnP's manifest, including zip-stored deps — so we just delegate
+    // to it. The one snag is that a registered customization hook makes Node thread a
+    // `conditions` option that PnP rejects ("aren't supported by PnP yet
+    // (conditions)"), so strip it first. The require/default condition PnP then
+    // applies is exactly right for `require()`. (Stripping is a harmless no-op when
+    // origResolveFilename is plain Node — i.e. not a PnP project.) This replaces the
+    // former `pnpapi.resolveRequest` reimplementation: simpler, and with no
+    // `findPnpApi` in the hot path there is no lookup-miss to leak a `conditions`
+    // crash on Windows.
+    if (options && "conditions" in options) {
+      options = { ...options };
+      delete options.conditions;
+    }
+    try {
+      return origResolveFilename.call(this, request, parent, isMain, options);
+    } catch (e) {
+      // Under PnP, an in-tree issuer requiring a dep NOT in its manifest makes PnP
+      // throw. That is nub's OWN transpile helpers (e.g. `@oxc-project/runtime`),
+      // injected into transpiled user code and resolved via NODE_PATH globalPaths
+      // (A30). Fall back to Node's native path resolver, which PnP does NOT patch.
+      // Gated to PnP so off-PnP a genuine miss surfaces Node's own error unchanged.
+      if (process.versions.pnp && e && e.code === "MODULE_NOT_FOUND") {
+        const lookupPaths = module_._resolveLookupPaths(request, parent) || [];
+        const found = module_._findPath(request, lookupPaths, isMain);
+        if (found) return found;
       }
-      // PnP couldn't resolve it (nub's OWN vendored deps, whose issuer is nub's
-      // out-of-tree install dir) or the api was momentarily unavailable. Use Node's
-      // native path primitives (`_resolveLookupPaths` + `_findPath`), which PnP does
-      // NOT patch — never `origResolveFilename` (PnP's, + `conditions`).
-      const lookupPaths = module_._resolveLookupPaths(request, parent) || [];
-      const found = module_._findPath(request, lookupPaths, isMain);
-      if (found) return found;
-      const err = new Error(`Cannot find module '${request}'`);
-      err.code = "MODULE_NOT_FOUND";
-      throw err;
+      throw e;
     }
-    return origResolveFilename.call(this, request, parent, isMain, options);
   };
 
   if (!withClassicTranspile) return;

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.20";
+export const NUB_VERSION = "0.0.21";