@vltpkg/cli-js 1.3.2 → 1.3.4

package/{chunk-IIXKXSLE.js → chunk-QGFDMXDH.js}

@@ -13,14 +13,15 @@ import {
   AbortError,
   SecurityArchive,
   pRetry
-} from "./chunk-4WQ76RJD.js";
+} from "./chunk-MVD5AUNS.js";
 import {
   Monorepo,
   PackageJson,
+  detectLibc,
   getUser,
   minimatch,
   platformCheck
-} from "./chunk-BUKZHMMK.js";
+} from "./chunk-INEKXXUQ.js";
 import {
   asDepID,
   baseDepID,
@@ -46,7 +47,7 @@ import {
 import {
   userAgent,
   userAgentHeaders
-} from "./chunk-3NWCWTIU.js";
+} from "./chunk-WXRS5PRL.js";
 import {
   graphStep,
   promiseSpawn
@@ -204,12 +205,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve13, reject) {
+        return new Promise(function(resolve14, reject) {
           isexe(path2, options || {}, function(er, is2) {
             if (er) {
               reject(er);
             } else {
-              resolve13(is2);
+              resolve14(is2);
             }
           });
         });
@@ -275,27 +276,27 @@ var require_which = __commonJS({
         opt = {};
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
-      const step = (i) => new Promise((resolve13, reject) => {
+      const step = (i) => new Promise((resolve14, reject) => {
         if (i === pathEnv.length)
-          return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
+          return opt.all && found.length ? resolve14(found) : reject(getNotFoundError(cmd));
         const ppRaw = pathEnv[i];
         const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
         const pCmd = path2.join(pathPart, cmd);
         const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-        resolve13(subStep(p, i, 0));
+        resolve14(subStep(p, i, 0));
       });
-      const subStep = (p, i, ii) => new Promise((resolve13, reject) => {
+      const subStep = (p, i, ii) => new Promise((resolve14, reject) => {
         if (ii === pathExt.length)
-          return resolve13(step(i + 1));
+          return resolve14(step(i + 1));
         const ext = pathExt[ii];
         isexe(p + ext, { pathExt: pathExtExe }, (er, is2) => {
           if (!er && is2) {
             if (opt.all)
               found.push(p + ext);
             else
-              return resolve13(p + ext);
+              return resolve14(p + ext);
           }
-          return resolve13(subStep(p, i, ii + 1));
+          return resolve14(subStep(p, i, ii + 1));
         });
       });
       return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -3984,7 +3985,7 @@ var require_processor = __commonJS({
           if (options === void 0) {
             options = {};
           }
-          return new Promise(function(resolve13, reject) {
+          return new Promise(function(resolve14, reject) {
             try {
               var root_1 = _this._root(rule, options);
               Promise.resolve(_this.func(root_1)).then(function(transform) {
@@ -3994,7 +3995,7 @@ var require_processor = __commonJS({
                   rule.selector = string;
                 }
                 return { transform, root: root_1, string };
-              }).then(resolve13, reject);
+              }).then(resolve14, reject);
             } catch (e) {
               reject(e);
               return;
@@ -4481,6 +4482,7 @@ var Node = class _Node {
   }
   #options;
   #location;
+  #resolvedLoc;
   #rawManifest;
   #optional = false;
   /**
@@ -4699,9 +4701,16 @@ var Node = class _Node {
   }
   /**
    * The resolved location of the node in the file system.
+   * Memoized per location and scurry cwd.
    */
   resolvedLocation(scurry) {
-    return scurry.cwd.resolve(this.location).fullpath();
+    const loc = this.location;
+    const { cwd } = scurry;
+    const m = this.#resolvedLoc;
+    if (m?.loc === loc && m.cwd === cwd) return m.path;
+    const path2 = cwd.resolve(loc).fullpath();
+    this.#resolvedLoc = { loc, cwd, path: path2 };
+    return path2;
   }
   /**
    * The location of the node_modules folder where this node's edgesOut
@@ -4713,7 +4722,11 @@ var Node = class _Node {
    */
   nodeModules(scurry) {
     const loc = this.resolvedLocation(scurry);
-    return this.inVltStore() ? loc.substring(0, loc.length - this.name.length - 1) : scurry.resolve(loc, "node_modules");
+    if (this.inVltStore()) {
+      return loc.substring(0, loc.length - this.name.length - 1);
+    }
+    const { sep: sep2 } = scurry.cwd;
+    return (loc.endsWith(sep2) ? loc : loc + sep2) + "node_modules";
   }
   constructor(options, id2, manifest, spec2, name, version) {
     this.#options = options;
@@ -8944,8 +8957,8 @@ var Query = class {
       specificity
     } = await walk({
       cancellable: async () => {
-        await new Promise((resolve13) => {
-          setTimeout(resolve13, 0);
+        await new Promise((resolve14) => {
+          setTimeout(resolve14, 0);
         });
         signal.throwIfAborted();
       },
@@ -10586,10 +10599,36 @@ var del = (diff2, node) => {
   diff2.nodes.add.delete(node);
   diff2.nodes.delete.add(node);
 };
+var isUnsupported = (node) => !!node.manifest?.deprecated || !platformCheck(
+  node.platform ?? node.manifest ?? {},
+  process.version,
+  process.platform,
+  process.arch
+);
+var pruneUnsupportedOptional = (diff2) => {
+  let pruned = false;
+  for (const node of diff2.nodes.add) {
+    if (node.inVltStore() && !node.extracted && node.isOptional() && isUnsupported(node)) {
+      del(diff2, node);
+      pruned = true;
+    }
+  }
+  if (!pruned) return;
+  for (const node of diff2.to.gc().values()) {
+    diff2.nodes.add.delete(node);
+    diff2.nodes.delete.add(node);
+  }
+  for (const edge of diff2.edges.add) {
+    if (diff2.to.nodes.get(edge.from.id) !== edge.from) {
+      diff2.edges.add.delete(edge);
+    }
+  }
+};
 
 // ../../src/graph/src/reify/bin-chmod.ts
 import { statSync as statSync3 } from "node:fs";
 import { chmod as chmod2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
 var binChmodAll = async (nodes, scurry) => {
   const chmods = [];
   for (const node of nodes) {
@@ -10601,9 +10640,7 @@ var binChmod = async (node, scurry) => {
   const chmods = [];
   if (!node.bins) return;
   for (const bin of Object.values(node.bins)) {
-    const path2 = scurry.resolve(
-      `${node.resolvedLocation(scurry)}/${bin}`
-    );
+    const path2 = join2(node.resolvedLocation(scurry), bin);
     let mode;
     try {
       mode = statSync3(path2).mode;
@@ -10618,10 +10655,10 @@ var binChmod = async (node, scurry) => {
 
 // ../../src/graph/src/reify/binding-gyp.ts
 import { lstatSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { join as join3 } from "node:path";
 var onDisk = (dir) => {
   try {
-    return !!lstatSync(join2(dir, "binding.gyp"), {
+    return !!lstatSync(join3(dir, "binding.gyp"), {
       throwIfNoEntry: false
     })?.isFile();
   } catch {
@@ -10633,6 +10670,108 @@ var hasBindingGyp = (node, scurry) => node.bindingGyp ?? onDisk(node.resolvedLoc
 // ../../src/graph/src/reify/scripts-manifest.ts
 var scriptsManifest = (manifest, dir, packageJson) => manifest.hasInstallScript && !manifest.scripts ? packageJson.read(dir) : manifest;
 
+// ../../src/graph/src/reify/unshare.ts
+import { randomBytes } from "node:crypto";
+import { lstatSync as lstatSync2, readdirSync, rmSync } from "node:fs";
+import {
+  chmod as chmod3,
+  readFile,
+  rename,
+  rm,
+  writeFile as writeFile2
+} from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// ../../node_modules/.vlt/~npm~promise-call-limit@3.0.2/node_modules/promise-call-limit/dist/esm/index.js
+import * as os from "node:os";
+var defLimit = "availableParallelism" in os ? Math.max(1, os.availableParallelism() - 1) : Math.max(1, os.cpus().length - 1);
+var callLimit = (queue, { limit: limit2 = defLimit, rejectLate } = {}) => new Promise((res, rej) => {
+  let active = 0;
+  let current = 0;
+  const results = [];
+  let rejected = false;
+  let rejection;
+  const reject = (er) => {
+    if (rejected)
+      return;
+    rejected = true;
+    rejection ??= er;
+    if (!rejectLate)
+      rej(rejection);
+  };
+  let resolved = false;
+  const resolve14 = () => {
+    if (resolved || active > 0)
+      return;
+    resolved = true;
+    res(results);
+  };
+  const run2 = () => {
+    const c = current++;
+    if (c >= queue.length)
+      return rejected ? reject() : resolve14();
+    active++;
+    const step = queue[c];
+    if (!step)
+      throw new Error("walked off queue");
+    results[c] = step().then((result) => {
+      active--;
+      results[c] = result;
+      return result;
+    }, (er) => {
+      active--;
+      reject(er);
+    }).then((result) => {
+      if (rejected && active === 0)
+        return rej(rejection);
+      run2();
+      return result;
+    });
+  };
+  for (let i = 0; i < limit2; i++)
+    run2();
+});
+
+// ../../src/graph/src/reify/unshare.ts
+var TMP = ".vlt-unshare-";
+var own = async (p, mode, tmp) => {
+  const body = await readFile(p);
+  try {
+    await writeFile2(tmp, body, { mode: mode & 511, flag: "wx" });
+    if (mode & 73) await chmod3(tmp, mode & 511);
+    await rename(tmp, p);
+  } catch (er) {
+    await rm(tmp, { force: true });
+    throw er;
+  }
+};
+var unshare = async (dir) => {
+  const pjPath = join4(dir, "package.json");
+  const pj = lstatSync2(pjPath, { throwIfNoEntry: false });
+  if (!pj || pj.nlink < 2) return;
+  const tag = `${TMP}${randomBytes(4).toString("hex")}-`;
+  let n = 0;
+  const shared = [];
+  const walk2 = (d) => {
+    for (const ent of readdirSync(d, { withFileTypes: true })) {
+      const p = join4(d, ent.name);
+      if (ent.isDirectory()) walk2(p);
+      else if (ent.isFile() && p !== pjPath) {
+        const { mode, nlink } = lstatSync2(p);
+        if (nlink > 1) {
+          const tmp = join4(d, `${tag}${n++}`);
+          shared.push(() => own(p, mode, tmp));
+        } else if (ent.name.startsWith(TMP)) {
+          rmSync(p);
+        }
+      }
+    }
+  };
+  walk2(dir);
+  await callLimit(shared, { limit: 16, rejectLate: true });
+  await own(pjPath, pj.mode, join4(dir, `${tag}${n}`));
+};
+
 // ../../src/graph/src/reify/build.ts
 var build = async (diff2, packageJson, scurry, allowScriptsNodes) => {
   const graph = diff2.to;
@@ -10686,26 +10825,28 @@ var visit = async (packageJson, scurry, node, signal, _path) => {
   } = scripts2;
   const hasImplicitInstall = hasBindingGyp(node, scurry) && !install2 && !preinstall;
   const runInstall = !!(install2 || preinstall || postinstall) || hasImplicitInstall;
+  const prepable = node.id.startsWith("git") || node.importer || !node.inVltStore();
+  const runPrepare = !!(prepare || preprepare || postprepare) && prepable;
+  if ((runInstall || runPrepare) && node.inVltStore())
+    await unshare(dir);
   if (runInstall) {
     await run({
       signal,
       arg0: "install",
       ignoreMissing: true,
       packageJson,
-      cwd: node.resolvedLocation(scurry),
+      cwd: dir,
       projectRoot: node.projectRoot,
       manifest
     });
   }
-  const prepable = node.id.startsWith("git") || node.importer || !node.inVltStore();
-  const runPrepare = !!(prepare || preprepare || postprepare) && prepable;
   if (runPrepare) {
     await run({
       signal,
       arg0: "prepare",
       ignoreMissing: true,
       packageJson,
-      cwd: node.resolvedLocation(scurry),
+      cwd: dir,
       projectRoot: node.projectRoot,
       manifest
     });
@@ -11233,7 +11374,7 @@ function mermaidOutput(options) {
 
 // ../../src/rollback-remove/src/index.ts
 import { spawn as spawn3 } from "node:child_process";
-import { rename } from "node:fs/promises";
+import { rename as rename2 } from "node:fs/promises";
 import { basename, dirname as dirname3 } from "node:path";
 
 // ../../src/rollback-remove/src/remove.ts
@@ -11249,7 +11390,7 @@ var RollbackRemove = class {
     if (this.#paths.has(path2)) return;
     const target = `${dirname3(path2)}/.VLT.DELETE.${this.#key}.${basename(path2)}`;
     try {
-      await rename(path2, target);
+      await rename2(path2, target);
     } catch (e) {
       if (e instanceof Error && "code" in e && /* c8 ignore start - very spurious weirdness on Windows */
       (e.code === "ENOENT" || e.code === "EPERM")) {
@@ -11290,7 +11431,7 @@ var RollbackRemove = class {
     for (const [original, moved] of this.#paths) {
       promises.push(
         rimraf(original).catch(() => {
-        }).then(() => rename(moved, original))
+        }).then(() => rename2(moved, original))
       );
     }
     await Promise.all(promises);
@@ -12474,7 +12615,7 @@ var canonicalizePeerIds = (graph, options = {}) => {
 
 // ../../src/graph/src/ideal/move-peer-store-dirs.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { rename as rename2 } from "node:fs/promises";
+import { rename as rename3 } from "node:fs/promises";
 var movePeerStoreDirs = async (moves, {
   scurry,
   remover
@@ -12494,7 +12635,7 @@ var movePeerStoreDirs = async (moves, {
       }
       const tmp = scurry.resolve(store, `.VLT.MOVE.${key}.${to}`);
       try {
-        await rename2(src, tmp);
+        await rename3(src, tmp);
       } catch {
         node.extracted = false;
         return;
@@ -12508,7 +12649,7 @@ var movePeerStoreDirs = async (moves, {
       const { node, tmp, dest } = s;
       try {
         await remover.rm(dest);
-        await rename2(tmp, dest);
+        await rename3(tmp, dest);
       } catch {
         node.extracted = false;
         try {
@@ -12611,12 +12752,12 @@ var isPathSecurityError = (er) => {
 };
 
 // ../../src/graph/src/reify/extract-node.ts
+import { lstatSync as lstatSync3 } from "node:fs";
 var getOptionalFailedNodeRemover = (node, diff2) => {
   return diff2 ? optionalFail(diff2, node) : node.isOptional() ? () => removeOptionalSubgraph(node.graph, node) : void 0;
 };
 var extractNode = async (node, scurry, remover, options, packageInfo, diff2) => {
   node.extracted = true;
-  const { manifest = {} } = node;
   const target = node.resolvedLocation(scurry);
   const from = scurry.resolve("");
   const spec2 = hydrate2(node.id, node.name, options);
@@ -12625,14 +12766,7 @@ var extractNode = async (node, scurry, remover, options, packageInfo, diff2) =>
     diff2
   );
   const { integrity, resolved } = node;
-  const platformData = node.platform ?? manifest;
-  if (removeOptionalFailedNode && (manifest.deprecated || !platformCheck(
-    platformData,
-    process.version,
-    process.platform,
-    process.arch
-    // libc is auto-detected by platformCheck when not provided
-  ))) {
+  if (removeOptionalFailedNode && isUnsupported(node)) {
     removeOptionalFailedNode();
     return {
       success: false,
@@ -12640,13 +12774,11 @@ var extractNode = async (node, scurry, remover, options, packageInfo, diff2) =>
       error: new Error("Platform check failed or package deprecated")
     };
   }
-  const { scripts: scripts2, hasInstallScript } = manifest;
   const extractOptions = {
     from,
     integrity,
     resolved,
-    fromLockfile: node.resolvedFromLockfile,
-    installScripts: !!(hasInstallScript || scripts2?.install || scripts2?.preinstall || scripts2?.postinstall)
+    fromLockfile: node.resolvedFromLockfile
   };
   const extracted = (r) => {
     if (r.integrity && !node.integrity) node.integrity = r.integrity;
@@ -12662,7 +12794,9 @@ var extractNode = async (node, scurry, remover, options, packageInfo, diff2) =>
     return { success: true, node };
   };
   try {
-    await remover.rm(target);
+    if (lstatSync3(target, { throwIfNoEntry: false })) {
+      await remover.rm(target);
+    }
     if (removeOptionalFailedNode) {
       try {
         return extracted(
@@ -13542,7 +13676,10 @@ var fetchManifestsForDeps = async (packageInfo, graph, fromNode, deps, scurry, o
       // `keepVersion` marks a fork that only differs by an optional peer
       // link, so the copy keeps the version it forked from instead of
       // re-resolving the range to the newest satisfying release
-      existingNode?.manifest && (existingNode.detached || peerCompatResult.keepVersion) ? Promise.resolve(existingNode.manifest) : packageInfo.manifest(spec2, { from }).then((manifest) => manifest).catch((er) => {
+      existingNode?.manifest && (existingNode.detached || peerCompatResult.keepVersion) ? Promise.resolve(existingNode.manifest) : packageInfo.manifest(
+        spec2,
+        isExplicit ? { from } : { from, backgroundRevalidate: true }
+      ).then((manifest) => manifest).catch((er) => {
         if (isPathSecurityError(er)) throw er;
         if (!isExplicit && (edgeOptional || fromNode.optional)) {
           return void 0;
@@ -13784,7 +13921,6 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
           peerContext,
           depth
         }) => {
-          seen.add(node.id);
           const result = await fetchManifestsForDeps(
             packageInfo,
             graph,
@@ -13861,15 +13997,12 @@ var appendNodes = async (packageInfo, graph, fromNode, deps, scurry, options, se
       levelResults.push(placed);
     }
     postPlacementPeerCheck(graph, levelResults);
+    const nextDepth = (currentLevelDeps[0]?.depth ?? 0) + 1;
     for (const childDepsToProcess of levelResults) {
       for (const childDep of childDepsToProcess) {
-        if (!seen.has(childDep.node.id)) {
-          const currentDepth = currentLevelDeps[0]?.depth ?? 0;
-          nextLevelDeps.push({
-            ...childDep,
-            depth: currentDepth + 1
-          });
-        }
+        if (seen.has(childDep.node.id)) continue;
+        seen.add(childDep.node.id);
+        nextLevelDeps.push({ ...childDep, depth: nextDepth });
       }
     }
     currentLevelDeps = nextLevelDeps;
@@ -14041,6 +14174,57 @@ var buildIdealFromStartingGraph = async (options) => {
   return options.graph;
 };
 
+// ../../src/graph/src/ideal/prefetch-resolve.ts
+var prefetchResolve = (graph, packageInfo, options) => {
+  if (options.modifiers) return 0;
+  const registry2 = options.registry;
+  if (!registry2) return 0;
+  const scopes = Object.keys(options["scoped-registries"] ?? {});
+  const scoped = (name) => scopes.some((scope2) => name.startsWith(`${scope2}/`));
+  const roots = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const importer of graph.importers) {
+    const manifest = importer.manifest;
+    if (!manifest) continue;
+    for (const field of [
+      "dependencies",
+      "devDependencies",
+      "optionalDependencies"
+    ]) {
+      const deps = manifest[field];
+      if (!deps) continue;
+      for (const [name, spec2] of Object.entries(deps)) {
+        if (typeof spec2 !== "string") continue;
+        if (spec2.includes(":") || scoped(name)) continue;
+        const key = `${name}@${spec2}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        roots.push({ name, spec: spec2 });
+      }
+    }
+  }
+  if (!roots.length) return 0;
+  const have = [];
+  for (const node of graph.nodes.values()) {
+    if (node.manifest && node.name && node.version && !scoped(node.name)) {
+      have.push(`${node.name}@${node.version}`);
+    }
+  }
+  packageInfo.prefetchResolve(registry2, {
+    roots,
+    have,
+    ...scopes.length ? { stop: { scopes } } : {},
+    platform: {
+      os: process.platform,
+      cpu: process.arch,
+      node: process.versions.node,
+      // undefined never serializes, so no libc means the field is absent
+      libc: detectLibc()
+    }
+  });
+  return roots.length;
+};
+
 // ../../src/graph/src/ideal/build.ts
 var getMap2 = (m) => m ?? /* @__PURE__ */ new Map();
 var validateFileDepNode = (graph, id2) => {
@@ -14077,6 +14261,7 @@ var build3 = async (options) => {
       monorepo
     });
   }
+  prefetchResolve(graph, packageInfo, options);
   const res = await buildIdealFromStartingGraph({
     ...options,
     scurry,
@@ -14103,63 +14288,13 @@ var build3 = async (options) => {
 // ../../src/graph/src/reify/index.ts
 import { availableParallelism as availableParallelism2 } from "node:os";
 
-// ../../node_modules/.vlt/~npm~promise-call-limit@3.0.2/node_modules/promise-call-limit/dist/esm/index.js
-import * as os from "node:os";
-var defLimit = "availableParallelism" in os ? Math.max(1, os.availableParallelism() - 1) : Math.max(1, os.cpus().length - 1);
-var callLimit = (queue, { limit: limit2 = defLimit, rejectLate } = {}) => new Promise((res, rej) => {
-  let active = 0;
-  let current = 0;
-  const results = [];
-  let rejected = false;
-  let rejection;
-  const reject = (er) => {
-    if (rejected)
-      return;
-    rejected = true;
-    rejection ??= er;
-    if (!rejectLate)
-      rej(rejection);
-  };
-  let resolved = false;
-  const resolve13 = () => {
-    if (resolved || active > 0)
-      return;
-    resolved = true;
-    res(results);
-  };
-  const run2 = () => {
-    const c = current++;
-    if (c >= queue.length)
-      return rejected ? reject() : resolve13();
-    active++;
-    const step = queue[c];
-    if (!step)
-      throw new Error("walked off queue");
-    results[c] = step().then((result) => {
-      active--;
-      results[c] = result;
-      return result;
-    }, (er) => {
-      active--;
-      reject(er);
-    }).then((result) => {
-      if (rejected && active === 0)
-        return rej(rejection);
-      run2();
-      return result;
-    });
-  };
-  for (let i = 0; i < limit2; i++)
-    run2();
-});
-
 // ../../src/cmd-shim/src/index.ts
 import {
-  chmod as chmod3,
+  chmod as chmod4,
   mkdir as mkdir2,
-  readFile as readFile2,
+  readFile as readFile3,
   stat as stat2,
-  writeFile as writeFile2
+  writeFile as writeFile3
 } from "node:fs/promises";
 import { dirname as dirname5, relative as relative2 } from "node:path";
 
@@ -14193,7 +14328,7 @@ var replaceDollarWithPercentPair = (value) => {
 };
 
 // ../../src/cmd-shim/src/read.ts
-import { lstat, readFile, readlink } from "node:fs/promises";
+import { lstat, readFile as readFile2, readlink } from "node:fs/promises";
 import { dirname as dirname4, resolve as resolve8 } from "node:path";
 
 // ../../src/cmd-shim/src/paths.ts
@@ -14245,7 +14380,7 @@ var readCmdShimIfExists = async (path2) => {
     if (st.isSymbolicLink()) {
       return resolve8(dirname4(path2), await readlink(path2));
     }
-    const contents = await readFile(path2);
+    const contents = await readFile2(path2);
     const destination = extractPath(path2, contents.toString());
     if (destination) return resolve8(dirname4(path2), destination);
   } catch {
@@ -14270,7 +14405,7 @@ var writeShim = async (from, to, remover) => {
     remover.rm(to + ".pwsh")
   ]);
   await mkdir2(dirname5(to), { recursive: true });
-  const data = await readFile2(from, "utf8").catch(() => "");
+  const data = await readFile3(from, "utf8").catch(() => "");
   if (!data) {
     return await writeShim_(from, to);
   }
@@ -14385,34 +14520,48 @@ exit $LASTEXITCODE
 `;
   }
   await Promise.all([
-    writeFile2(to + ".cmd", cmd, "utf8"),
-    writeFile2(to + ".ps1", pwsh, "utf8"),
-    writeFile2(to, sh, "utf8")
+    writeFile3(to + ".cmd", cmd, "utf8"),
+    writeFile3(to + ".ps1", pwsh, "utf8"),
+    writeFile3(to, sh, "utf8")
   ]);
   await chmodShim(to);
 };
 var chmodShim = async (to) => await Promise.all([
-  chmod3(to, 493),
-  chmod3(to + ".cmd", 493),
-  chmod3(to + ".ps1", 493)
+  chmod4(to, 493),
+  chmod4(to + ".cmd", 493),
+  chmod4(to + ".ps1", 493)
 ]);
 
 // ../../src/graph/src/reify/add-edge.ts
-import { mkdir as mkdir3, symlink } from "node:fs/promises";
-import { dirname as dirname6, relative as relative3, resolve as resolve9 } from "node:path";
+import { symlinkSync as symlinkSync2 } from "node:fs";
+import { dirname as dirname7, relative as relative3, resolve as resolve9 } from "node:path";
+
+// ../../src/graph/src/reify/symlink-sync.ts
+import { mkdirSync as mkdirSync2, symlinkSync } from "node:fs";
+import { dirname as dirname6 } from "node:path";
+var symlinkSyncMkdirp = (target, link2, type2) => {
+  try {
+    symlinkSync(target, link2, type2);
+  } catch (er) {
+    if (er.code !== "ENOENT") throw er;
+    mkdirSync2(dirname6(link2), { recursive: true });
+    symlinkSync(target, link2, type2);
+  }
+};
+
+// ../../src/graph/src/reify/add-edge.ts
 var clobberSymlink = async (target, link2, remover, type2 = "file") => {
   const symlinkType = type2 === "dir" && process.platform === "win32" ? "junction" : type2;
-  const symlinkTarget = symlinkType === "junction" ? resolve9(dirname6(link2), target) : target;
-  await mkdir3(dirname6(link2), { recursive: true });
+  const symlinkTarget = symlinkType === "junction" ? resolve9(dirname7(link2), target) : target;
   try {
-    await symlink(symlinkTarget, link2, symlinkType);
+    symlinkSyncMkdirp(symlinkTarget, link2, symlinkType);
   } catch (er) {
     if (er.code !== "EEXIST") {
       throw er;
     }
     await remover.rm(link2);
     try {
-      await symlink(symlinkTarget, link2, symlinkType);
+      symlinkSync2(symlinkTarget, link2, symlinkType);
     } catch (er2) {
       if (er2.code !== "EEXIST") {
         throw er2;
@@ -14422,17 +14571,13 @@ var clobberSymlink = async (target, link2, remover, type2 = "file") => {
 };
 var addEdge = async (edge, scurry, remover, bins) => {
   if (!edge.to) return;
-  const binRoot = scurry.resolve(
-    edge.from.nodeModules(scurry),
-    ".bin"
-  );
-  const path2 = scurry.resolve(
-    edge.from.nodeModules(scurry),
-    edge.spec.name
-  );
+  const { sep: sep2 } = scurry.cwd;
+  const nm = edge.from.nodeModules(scurry);
+  const binRoot = nm + sep2 + ".bin";
+  const path2 = nm + sep2 + edge.spec.name.replace("/", sep2);
   const promises = [];
   const target = relative3(
-    dirname6(path2),
+    dirname7(path2),
     edge.to.resolvedLocation(scurry)
   );
   const p = clobberSymlink(target, path2, remover, "dir");
@@ -14440,8 +14585,8 @@ var addEdge = async (edge, scurry, remover, bins) => {
   else promises.push(p);
   if (bins) {
     for (const [key, val] of Object.entries(bins)) {
-      const link2 = scurry.resolve(binRoot, key);
-      const absTarget = scurry.resolve(path2, val);
+      const link2 = resolve9(binRoot, key);
+      const absTarget = resolve9(path2, val);
       const target2 = relative3(binRoot, absTarget);
       promises.push(
         process.platform === "win32" ? cmdShimIfExists(absTarget, link2, remover) : clobberSymlink(target2, link2, remover)
@@ -14477,6 +14622,7 @@ var addNodes = (diff2, scurry, remover, options, packageInfo) => {
 };
 
 // ../../src/graph/src/reify/delete-edge.ts
+import { resolve as resolve10 } from "node:path";
 var rmBinPosix = (remover, bin) => {
   return [remover.rm(bin)];
 };
@@ -14493,15 +14639,16 @@ var deleteEdge = async (edge, scurry, remover) => {
     spec: { name },
     to
   } = edge;
+  const { sep: sep2 } = scurry.cwd;
   const nm = edge.from.nodeModules(scurry);
-  const path2 = scurry.resolve(nm, name);
-  const binRoot = scurry.cwd.resolve(`${nm}/.bin`);
+  const path2 = nm + sep2 + name.replace("/", sep2);
+  const binRoot = nm + sep2 + ".bin";
   const promises = [];
   promises.push(remover.rm(path2));
   const bins = to?.bins;
   if (bins) {
     for (const key of Object.keys(bins)) {
-      const bin = binRoot.resolve(key).fullpath();
+      const bin = resolve10(binRoot, key);
       promises.push(...rmBin(remover, bin));
     }
   }
@@ -14558,10 +14705,11 @@ var checkNeededBuild = (options) => {
 // ../../src/graph/src/reify/delete-nodes.ts
 var deleteNodes = (diff2, remover, scurry) => {
   const store = scurry.resolve("node_modules/.vlt");
+  const { sep: sep2 } = scurry.cwd;
   const rmActions = [];
   for (const node of diff2.nodes.delete) {
     if (!node.inVltStore()) continue;
-    rmActions.push(remover.rm(scurry.resolve(store, node.id)));
+    rmActions.push(remover.rm(store + sep2 + node.id));
     for (const edge of node.edgesIn) {
       rmActions.push(deleteEdge(edge, scurry, remover));
     }
@@ -14570,8 +14718,8 @@ var deleteNodes = (diff2, remover, scurry) => {
 };
 
 // ../../src/graph/src/reify/internal-hoist.ts
-import { mkdir as mkdir4, symlink as symlink2 } from "node:fs/promises";
-import { dirname as dirname7, relative as relative4 } from "node:path";
+import { mkdir as mkdir3 } from "node:fs/promises";
+import { dirname as dirname8, relative as relative4 } from "node:path";
 var pickNodeToHoist = (nodes) => {
   let pick = void 0;
   let pickNode = void 0;
@@ -14652,7 +14800,7 @@ var internalHoist = async (graph, options, remover) => {
   const hoistDir = scurry.cwd.resolve(
     "node_modules/.vlt/node_modules"
   );
-  await mkdir4(hoistDir.fullpath(), { recursive: true });
+  await mkdir3(hoistDir.fullpath(), { recursive: true });
   const removes = [];
   for (const entry of await hoistDir.readdir()) {
     const name = entry.name;
@@ -14679,22 +14827,15 @@ var internalHoist = async (graph, options, remover) => {
     }
   }
   await Promise.all(removes);
-  const symlinks = [];
+  const hoistPath = hoistDir.fullpath();
+  const vlt = scurry.resolve("node_modules/.vlt");
+  const { sep: sep2 } = scurry.cwd;
+  const native = (n) => n.replace("/", sep2);
   for (const [name, { name: nodeName, id: id2 }] of links) {
-    const target = scurry.resolve(
-      `node_modules/.vlt/${id2}/node_modules/${nodeName}`
-    );
-    const path2 = scurry.resolve(
-      `node_modules/.vlt/node_modules/${name}`
-    );
-    if (name.includes("/")) {
-      await mkdir4(dirname7(path2), { recursive: true });
-    }
-    symlinks.push(
-      symlink2(relative4(dirname7(path2), target), path2, "dir")
-    );
+    const target = vlt + sep2 + id2 + sep2 + "node_modules" + sep2 + native(nodeName);
+    const path2 = hoistPath + sep2 + native(name);
+    symlinkSyncMkdirp(relative4(dirname8(path2), target), path2, "dir");
   }
-  await Promise.all(symlinks);
 };
 var checkExisting = async (name, entry, links, removes, scurry, remover) => {
   const target = await entry.readlink();
@@ -14942,6 +15083,7 @@ var reify_ = async (options, diff2, remover, saveImportersPackageJson) => {
   const res = {};
   const { packageInfo, packageJson, scurry, allowScripts } = options;
   const lfData = lockfileData(options);
+  pruneUnsupportedOptional(diff2);
   const actions = addNodes(
     diff2,
     scurry,
@@ -14992,8 +15134,8 @@ var reify_ = async (options, diff2, remover, saveImportersPackageJson) => {
 };
 
 // ../../src/graph/src/install.ts
-import { existsSync as existsSync6, rmSync as rmSync3 } from "node:fs";
-import { resolve as resolve12 } from "node:path";
+import { existsSync as existsSync6, rmSync as rmSync4 } from "node:fs";
+import { resolve as resolve13 } from "node:path";
 
 // ../../src/graph/src/lockfile/format-options-change.ts
 var redactUserinfo = (value) => {
@@ -15012,8 +15154,8 @@ var formatOptionsChange = ({
 }) => `${section}:${key === void 0 ? "" : ` ${key}`} ` + (from === void 0 ? "(missing)" : `"${redactUserinfo(from)}"`) + ` -> ${to === void 0 ? "(removed)" : `"${redactUserinfo(to)}"`}`;
 
 // ../../src/graph/src/uninstall.ts
-import { existsSync as existsSync4, rmSync } from "node:fs";
-import { resolve as resolve10 } from "node:path";
+import { existsSync as existsSync4, rmSync as rmSync2 } from "node:fs";
+import { resolve as resolve11 } from "node:path";
 var uninstall = async (options, remove) => {
   const mainManifest = options.packageJson.read(options.projectRoot);
   const modifiers = GraphModifier.maybeLoad(options);
@@ -15060,12 +15202,12 @@ var uninstall = async (options, remove) => {
     await remover.rollback().catch(() => {
     });
     try {
-      const hiddenLockfile = resolve10(
+      const hiddenLockfile = resolve11(
         options.projectRoot,
         "node_modules/.vlt-lock.json"
       );
       if (existsSync4(hiddenLockfile)) {
-        rmSync(hiddenLockfile, { force: true });
+        rmSync2(hiddenLockfile, { force: true });
       }
     } catch {
     }
@@ -15074,8 +15216,8 @@ var uninstall = async (options, remove) => {
 };
 
 // ../../src/graph/src/update.ts
-import { existsSync as existsSync5, rmSync as rmSync2 } from "node:fs";
-import { resolve as resolve11 } from "node:path";
+import { existsSync as existsSync5, rmSync as rmSync3 } from "node:fs";
+import { resolve as resolve12 } from "node:path";
 var update = async (options) => {
   let mainManifest = void 0;
   try {
@@ -15124,12 +15266,12 @@ var update = async (options) => {
     await remover.rollback().catch(() => {
     });
     try {
-      const hiddenLockfile = resolve11(
+      const hiddenLockfile = resolve12(
         options.projectRoot,
         "node_modules/.vlt-lock.json"
       );
       if (existsSync5(hiddenLockfile)) {
-        rmSync2(hiddenLockfile, { force: true });
+        rmSync3(hiddenLockfile, { force: true });
       }
     } catch {
     }
@@ -15223,7 +15365,7 @@ var install = async (options, add) => {
     );
   }
   if (options.expectLockfile || options.frozenLockfile) {
-    const lockfilePath = resolve12(options.projectRoot, "vlt-lock.json");
+    const lockfilePath = resolve13(options.projectRoot, "vlt-lock.json");
     if (!existsSync6(lockfilePath)) {
       throw error(
         "vlt-lock.json file is required when using --expect-lockfile, --frozen-lockfile, or ci command",
@@ -15342,7 +15484,7 @@ var install = async (options, add) => {
           );
         }
       }
-      const lockfilePath = resolve12(
+      const lockfilePath = resolve13(
         options.projectRoot,
         "vlt-lock.json"
       );
@@ -15356,7 +15498,7 @@ var install = async (options, add) => {
   }
   const remover = new RollbackRemove();
   if (options.cleanInstall) {
-    const nodeModulesPath = resolve12(
+    const nodeModulesPath = resolve13(
       options.projectRoot,
       "node_modules"
     );
@@ -15424,12 +15566,12 @@ var install = async (options, add) => {
     await remover.rollback().catch(() => {
     });
     try {
-      const hiddenLockfile = resolve12(
+      const hiddenLockfile = resolve13(
         options.projectRoot,
         "node_modules/.vlt-lock.json"
       );
       if (existsSync6(hiddenLockfile)) {
-        rmSync3(hiddenLockfile, { force: true });
+        rmSync4(hiddenLockfile, { force: true });
       }
     } catch {
     }
@@ -15448,12 +15590,12 @@ export {
   execFG,
   runExec,
   runExecFG,
+  callLimit,
   Query,
   build2 as build,
   jsonOutput,
   humanReadableOutput,
   mermaidOutput,
-  callLimit,
   findCmdShimIfExists,
   RollbackRemove,
   GraphModifier,