@nubjs/nub-win32-x64 0.0.17 → 0.0.19

package/package.json

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

package/runtime/pnp-bin-run.cjs

@@ -0,0 +1,85 @@
+// nubx under Yarn PnP — resolve a bin name to its script and RUN it, the way
+// `yarn exec` does. nub runs this file as its (augmented) entry, having injected
+// `--require .pnp.cjs`, so `findPnpApi` is set up and the zipfs `fs` patch is live.
+//
+// Invoked as:  nub <this> <binName> [args...]
+//
+// Two things matter:
+//   1. PnP has no `node_modules/.bin`, so we find the bin by walking the top-level
+//      package's dependencies and matching `package.json#bin` (what Yarn's own bin
+//      registry does), via the public pnpapi.
+//   2. We load the resolved script with `require()` — the CJS path, where PnP's `fs`
+//      patch reads zip-stored packages. Running it as a node *entry* instead would,
+//      on the compat tier (Node <22.15, where nub augments via an `--import` ESM
+//      preload), route the entry through the ESM loader whose existence check
+//      bypasses PnP's `fs` patch and throws ERR_MODULE_NOT_FOUND on the zip path.
+//      `require()` (with a dynamic-import fallback for an ESM bin) sidesteps that and
+//      keeps nub's augmentation active in-process — matching `yarn exec` on every
+//      supported Node.
+const path = require("node:path");
+const fs = require("node:fs");
+const { pathToFileURL } = require("node:url");
+const { cwdIssuer } = require("./pnp-util.cjs");
+
+const want = process.argv[2];
+const rest = process.argv.slice(3);
+
+// `require("pnpapi")` throws for an out-of-tree issuer (this file lives in nub's
+// install dir); `findPnpApi` resolves by the queried path, so it works here.
+const api = require("node:module").findPnpApi(cwdIssuer());
+if (!api) {
+  process.stderr.write("nubx: not a Yarn PnP project\n");
+  process.exit(127);
+}
+
+// bin name -> relative script path. A string `bin` is named after the package
+// (its unscoped tail); an object maps explicit names.
+function binsOf(pkg) {
+  const b = pkg.bin;
+  if (!b) return {};
+  if (typeof b === "string") return { [(pkg.name || "").split("/").pop()]: b };
+  return b;
+}
+
+let script = null;
+const top = api.getPackageInformation(api.topLevel);
+for (const [name, reference] of top.packageDependencies) {
+  if (reference == null) continue;
+  const info = api.getPackageInformation(api.getLocator(name, reference));
+  if (!info) continue;
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(path.join(info.packageLocation, "package.json"), "utf8"));
+  } catch {
+    continue;
+  }
+  const rel = binsOf(pkg)[want];
+  if (rel) {
+    script = path.join(info.packageLocation, rel);
+    break;
+  }
+}
+
+if (!script) {
+  process.stderr.write(
+    `nubx: '${want}' not found in Yarn PnP dependencies.\n` +
+      `      add it (yarn add ${want}), or run it ad-hoc with: yarn dlx ${want}\n`,
+  );
+  process.exit(127);
+}
+
+// Run the bin as if it were the entry: present its own argv, then load it via the
+// zip-safe CJS path. Fall back to dynamic import for an ESM bin.
+process.argv = [process.argv[0], script, ...rest];
+try {
+  require(script);
+} catch (e) {
+  if (e && e.code === "ERR_REQUIRE_ESM") {
+    import(pathToFileURL(script).href).catch((err) => {
+      console.error(err);
+      process.exit(1);
+    });
+  } else {
+    throw e;
+  }
+}

package/runtime/pnp-util.cjs

@@ -0,0 +1,51 @@
+// 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.)
+const { readFileSync } = require("node:fs");
+const { 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.
+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) {
+  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;
+  }
+}
+
+// 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) {
+  const issuer = parentURL ? fileURLToPath(parentURL) : cwdIssuer();
+  const resolved = pnp.resolveRequest(specifier, issuer);
+  if (!resolved) return null;
+  const format = pnpFormat(pnp, resolved);
+  return { url: pathToFileURL(resolved).href, shortCircuit: true, ...(format && { format }) };
+}
+
+module.exports = { pnpResolveEsm, cwdIssuer };

package/runtime/preload-async-hooks.mjs

@@ -21,6 +21,34 @@ import {
   TRANSPILE_EXTS, DATA_EXTS,
   extname, resolveSpec, loadTranspile, loadData,
 } from "./transform-core.mjs";
+import { createRequire, isBuiltin } from "node:module";
+import { existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { pnpResolveEsm } from "./pnp-util.cjs";
+
+// Yarn PnP handle for this loader worker. The worker runs in its own thread where
+// `.pnp.cjs` was never --require'd, so neither the `pnpapi` builtin nor
+// `module.findPnpApi` is installed here (the main-thread preload uses findPnpApi; it
+// can't reach across to this realm). So bootstrap PnP for this thread directly: walk
+// up from cwd to the `.pnp.cjs` Rust located and require it by absolute path — that
+// returns the pnpapi object. nub then resolves PnP specifiers via
+// `pnpapi.resolveRequest` (its public, conditions-free resolver), mirroring the main
+// thread, so there is no need to register Yarn's `.pnp.loader.mjs` (which deadlocks
+// against the fast tier's `module.registerHooks`). `null` when not a PnP run.
+const __pnp = (() => {
+  if (!process.versions.pnp) return null;
+  const req = createRequire(import.meta.url);
+  try {
+    let dir = process.cwd();
+    for (;;) {
+      const candidate = join(dir, ".pnp.cjs");
+      if (existsSync(candidate)) return req(candidate);
+      const parent = dirname(dir);
+      if (parent === dir) return null;
+      dir = parent;
+    }
+  } catch { return null; }
+})();
 
 // Node calls this once per worker when the main thread invokes
 // `module.register(url, parentURL, { data })`. We accept and ignore the payload
@@ -31,7 +59,16 @@ 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);
+  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).
+  if (__pnp && !isBuiltin(specifier) && !specifier.startsWith("node:")) {
+    try {
+      const res = pnpResolveEsm(__pnp, specifier, context.parentURL);
+      if (res) return res;
+    } catch { /* fall through to Node's resolver */ }
+  }
+  return nextResolve(specifier, context);
 }
 
 // ── Load hook ───────────────────────────────────────────────────────

package/runtime/preload-common.cjs

@@ -20,6 +20,44 @@ const { readdirSync } = require("node:fs");
 const { fileURLToPath, pathToFileURL } = require("node:url");
 const { join, dirname, extname: pathExtname } = require("node:path");
 
+// Yarn PnP API handle, fetched lazily via Node's `module.findPnpApi`. `.pnp.cjs`
+// (injected by the Rust spawn layer via --require, ahead of nub's preload) sets
+// `process.versions.pnp` and installs `findPnpApi`, which returns the pnpapi object
+// governing a given path. Unlike a bare `require("pnpapi")` — which throws here,
+// since this preload lives in nub's install dir, OUTSIDE the user's PnP tree —
+// `findPnpApi` resolves by the queried path, so an out-of-tree issuer works. Being
+// a plain query it never re-enters nub's resolve hooks, so there is no ordering
+// constraint with `module.registerHooks` (the reason the previous abs-path require
+// was load-bearing-fragile). nub resolves PnP specifiers through
+// `pnpapi.resolveRequest` (its public, conditions-free resolver) in both the
+// registerHooks resolve hook and the `_resolveFilename` override below. No env var
+// (brand boundary); `null` when this is not a PnP run.
+let __pnpApi;
+function pnpApi() {
+  if (__pnpApi) return __pnpApi; // cache only a SUCCESSFUL lookup (see below)
+  if (!process.versions.pnp) return null;
+  // `findPnpApi` matches by the queried path. A single synthesized `cwd + sep` anchor
+  // can miss on Windows (drive-letter casing, 8.3 short paths, trailing separator),
+  // and a transient early miss must NOT be cached sticky — otherwise every later
+  // resolution falls through to PnP's `_resolveFilename`, which rejects the
+  // `conditions` option Node injects under a registered hook (the intermittent
+  // Windows `conditions` crash). So try several real in-tree anchors and cache only
+  // on success: `argv[1]` is the user's entry file (in-tree for `nub <file>`); cwd
+  // covers `nub run` / `nub exec`.
+  for (const anchor of [process.argv[1], cwdIssuer(), process.cwd()]) {
+    if (!anchor) continue;
+    try {
+      const api = module_.findPnpApi(anchor);
+      if (api) return (__pnpApi = api);
+    } catch {}
+  }
+  return null;
+}
+
+// Shared PnP ESM resolution (resolveRequest + format) + the directory-issuer
+// helper, identical to the compat worker's — see runtime/pnp-util.cjs.
+const { pnpResolveEsm, cwdIssuer } = require("./pnp-util.cjs");
+
 // ── Watch-mode dependency reporting (main thread only) ──────────────
 // Under `nub watch`, Node's FilesWatcher only watches files in the import graph;
 // config files (tsconfig.json, package.json) and `.env*` are NOT in any graph, so
@@ -103,7 +141,24 @@ function makeHooks(core, watchReporting) {
 
   function resolve(specifier, context, nextResolve) {
     const r = core.resolveSpec(specifier, context.parentURL);
-    return r ?? nextResolve(specifier, context);
+    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).
+    const pnp = pnpApi();
+    if (pnp && !module_.isBuiltin(specifier) && !specifier.startsWith("node:")) {
+      try {
+        const res = pnpResolveEsm(pnp, specifier, context && context.parentURL);
+        if (res) return res;
+      } catch { /* fall through to Node's resolver */ }
+    }
+    return nextResolve(specifier, context);
   }
 
   function load(url, context, nextLoad) {
@@ -247,6 +302,45 @@ 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 */ }
+      }
+      // 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;
+    }
     return origResolveFilename.call(this, request, parent, isMain, options);
   };
 

package/runtime/preload.cjs

@@ -114,6 +114,12 @@ if (!requireEsmDisabled) {
   const { resolve, load } = common.makeHooks(core, watchReporting);
   module_.registerHooks({ resolve, load });
   common.installCjsRequireHooks(core, false);
+  // NOTE: no Yarn `.pnp.loader.mjs` registration. nub's own `resolve` hook already
+  // routes PnP specifiers through `pnpapi.resolveRequest` (see makeHooks /
+  // installCjsRequireHooks), covering both `import` and `require` of PnP deps.
+  // Registering Yarn's ESM loader ON TOP of the sync `module.registerHooks` hooks
+  // deadlocks ESM entry loading (silent exit) — both hook systems intercept ESM
+  // resolution. The compat tier (preload-async-hooks.mjs) resolves PnP the same way.
 
   // ── Sync polyfills + lazy ESM-side-effect polyfills ───────────────
   installSyncPolyfills(__preloadedPolyfills);

package/runtime/preload.mjs

@@ -65,7 +65,9 @@ if (__isFastTier) {
   module.registerHooks({ resolve, load });
   common.installCjsRequireHooks(core, false);
 } else if (__isCompatTier) {
-  // Compat path: ESM `import` hooks run in a dedicated loader worker thread.
+  // 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);
   // (The main-thread require() shim's module-format + decorator detection is a
   // synchronous native addon call now — no parser warm-up; the old

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