@pnpm/exe 11.20.0 → 11.22.0

package/dist/worker.js

@@ -8388,21 +8388,18 @@ function removeContentsOfDirSync(dir) {
 // ../fs/indexed-pkg-importer/lib/importIndexedDir.js
 var import_sanitize_filename = __toESM(require_sanitize_filename(), 1);
 var filenameConflictsLogger = logger("_filename-conflicts");
+var RENAME_RETRY_BUDGET_MS = 6e4;
+var RENAME_RETRY_BACKOFF_CAP_MS = 100;
+var FILE_COMPARE_BUFFER_SIZE = 64 * 1024;
+var renameRetrySleepBuffer = new Int32Array(new SharedArrayBuffer(4));
 function importIndexedDir(importer, newDir, filenames, opts2) {
-  if (!opts2.keepModulesDir) {
-    if (opts2.safeToSkip) {
-      try {
-        fs9.mkdirSync(newDir, { recursive: true });
-        tryImportIndexedDir(importer, newDir, filenames);
-        return;
-      } catch (err) {
-        if (util6.types.isNativeError(err) && "code" in err && err.code === "EEXIST" && allFilesMatch(newDir, filenames)) {
-          return;
-        }
-      }
-    } else if (tryExclusiveImport(importer, newDir, filenames)) {
-      return;
-    }
+  const dirImport = { importer, newDir, filenames, opts: opts2 };
+  if (opts2.safeToSkip && opts2.resolvedFrom !== "local-dir") {
+    importIntoSharedDir(dirImport);
+    return;
+  }
+  if (!opts2.keepModulesDir && tryExclusiveImport(importer, newDir, filenames)) {
+    return;
   }
   const stage = fastPathTemp(newDir);
   try {
@@ -8416,50 +8413,160 @@ function importIndexedDir(importer, newDir, filenames, opts2) {
       rimrafSync(stage);
     } catch {
     }
-    if (util6.types.isNativeError(err) && "code" in err && err.code === "EEXIST") {
-      const { uniqueFileMap, conflictingFileNames } = getUniqueFileMap(filenames);
-      if (conflictingFileNames.size === 0)
-        throw err;
-      filenameConflictsLogger.debug({
-        conflicts: Object.fromEntries(conflictingFileNames),
-        writingTo: newDir
-      });
-      globalWarn(`Not all files were linked to "${path13.relative(process.cwd(), newDir)}". Some of the files have equal names in different case, which is an issue on case-insensitive filesystems. The conflicting file names are: ${JSON.stringify(Object.fromEntries(conflictingFileNames))}`);
-      importIndexedDir(importer, newDir, uniqueFileMap, opts2);
+    if (retryWithFixedFileMap(err, dirImport))
       return;
+    throw err;
+  }
+  try {
+    renameOverwriteSync(stage, newDir);
+  } catch (renameErr) {
+    try {
+      rimrafSync(stage);
+    } catch {
     }
-    if (util6.types.isNativeError(err) && "code" in err && err.code === "ENOENT") {
-      if (retryWithSanitizedFilenames(importer, newDir, filenames, opts2))
-        return;
+    throw renameErr;
+  }
+}
+function importIntoSharedDir(dirImport) {
+  const { importer, newDir, filenames } = dirImport;
+  fs9.mkdirSync(path13.dirname(newDir), { recursive: true });
+  let created = false;
+  try {
+    fs9.mkdirSync(newDir);
+    created = true;
+  } catch (err) {
+    if (!util6.types.isNativeError(err) || !("code" in err) || err.code !== "EEXIST")
       throw err;
+  }
+  if (created) {
+    try {
+      tryImportIndexedDir(importer, newDir, filenames);
+      return;
+    } catch (err) {
+      if (retryWithFixedFileMap(err, dirImport))
+        return;
+    }
+  }
+  if (allFilesMatch(newDir, filenames))
+    return;
+  try {
+    repairIndexedDir(dirImport);
+  } catch (err) {
+    if (retryWithFixedFileMap(err, dirImport))
+      return;
+    throw err;
+  }
+}
+function repairIndexedDir({ importer, newDir, filenames }) {
+  makeFileMapDirs(newDir, filenames, { clearBlockers: true });
+  let packageJsonSrc;
+  for (const [f, src2] of filenames) {
+    if (f === "package.json") {
+      packageJsonSrc = src2;
+      continue;
+    }
+    replaceFileIfDifferent(importer.importFile, src2, path13.join(newDir, f));
+  }
+  if (packageJsonSrc !== void 0) {
+    replaceFileIfDifferent(importer.importFile, packageJsonSrc, path13.join(newDir, "package.json"));
+  }
+}
+function replaceFileIfDifferent(importFile, src2, dest) {
+  if (mismatchReason(dest, src2) === void 0)
+    return;
+  const tmp = fastPathTemp(dest);
+  try {
+    importFile(src2, tmp);
+  } catch (err) {
+    try {
+      fs9.unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  try {
+    clearDirBlockingFile(dest);
+    renameFileWithRetry(tmp, dest);
+  } catch (err) {
+    try {
+      fs9.unlinkSync(tmp);
+    } catch {
     }
+    if (mismatchReason(dest, src2) === void 0)
+      return;
     throw err;
   }
-  if (opts2.safeToSkip) {
+}
+function renameFileWithRetry(src2, dest) {
+  const startedAt = Date.now();
+  let backoffMs = 0;
+  for (; ; ) {
     try {
-      fs9.renameSync(stage, newDir);
+      fs9.renameSync(src2, dest);
       return;
     } catch (err) {
-      if (util6.types.isNativeError(err) && "code" in err && (err.code === "ENOTEMPTY" || err.code === "EEXIST" || err.code === "EPERM")) {
-        if (allFilesMatch(newDir, filenames)) {
-          try {
-            rimrafSync(stage);
-          } catch {
-          }
-          return;
-        }
-      }
+      if (!isTransientRenameError(err) || Date.now() - startedAt >= RENAME_RETRY_BUDGET_MS)
+        throw err;
+      if (backoffMs > 0)
+        Atomics.wait(renameRetrySleepBuffer, 0, 0, backoffMs);
+      backoffMs = Math.min(backoffMs + 10, RENAME_RETRY_BACKOFF_CAP_MS);
     }
   }
+}
+function isTransientRenameError(err) {
+  return process.platform === "win32" && util6.types.isNativeError(err) && "code" in err && (err.code === "EPERM" || err.code === "EACCES" || err.code === "EBUSY");
+}
+function clearDirBlockingFile(dest) {
+  let stats;
   try {
-    renameOverwriteSync(stage, newDir);
-  } catch (renameErr) {
+    stats = fs9.lstatSync(dest);
+  } catch (err) {
+    if (util6.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  if (stats.isDirectory()) {
+    rimrafSync(dest);
+  }
+}
+function clearDirentBlockingDir(newDir, relativeDir) {
+  let dir = newDir;
+  for (const segment of relativeDir.split(/[\\/]/)) {
+    dir = path13.join(dir, segment);
+    let stats;
     try {
-      rimrafSync(stage);
-    } catch {
+      stats = fs9.lstatSync(dir);
+    } catch (err) {
+      if (util6.types.isNativeError(err) && "code" in err && err.code === "ENOENT")
+        return;
+      throw err;
     }
-    throw renameErr;
+    if (stats.isDirectory())
+      continue;
+    fs9.unlinkSync(dir);
+    return;
+  }
+}
+function retryWithFixedFileMap(err, dirImport) {
+  const { importer, newDir, filenames, opts: opts2 } = dirImport;
+  if (!util6.types.isNativeError(err) || !("code" in err))
+    return false;
+  if (err.code === "EEXIST") {
+    const { uniqueFileMap, conflictingFileNames } = getUniqueFileMap(filenames);
+    if (conflictingFileNames.size === 0)
+      return false;
+    filenameConflictsLogger.debug({
+      conflicts: Object.fromEntries(conflictingFileNames),
+      writingTo: newDir
+    });
+    globalWarn(`Not all files were linked to "${path13.relative(process.cwd(), newDir)}". Some of the files have equal names in different case, which is an issue on case-insensitive filesystems. The conflicting file names are: ${JSON.stringify(Object.fromEntries(conflictingFileNames))}`);
+    importIndexedDir(importer, newDir, uniqueFileMap, opts2);
+    return true;
   }
+  if (err.code === "ENOENT") {
+    return retryWithSanitizedFilenames(dirImport);
+  }
+  return false;
 }
 function tryExclusiveImport(importer, newDir, filenames) {
   fs9.mkdirSync(path13.dirname(newDir), { recursive: true });
@@ -8482,29 +8589,67 @@ function tryExclusiveImport(importer, newDir, filenames) {
   }
 }
 function allFilesMatch(dir, filenames) {
+  const markerSrc = filenames.get("package.json");
+  if (markerSrc !== void 0 && !fileMatches(dir, "package.json", markerSrc))
+    return false;
   for (const [f, src2] of filenames) {
-    const target2 = path13.join(dir, f);
+    if (f === "package.json")
+      continue;
+    if (!fileMatches(dir, f, src2))
+      return false;
+  }
+  return true;
+}
+function fileMatches(dir, f, src2) {
+  const reason = mismatchReason(path13.join(dir, f), src2);
+  if (reason === void 0)
+    return true;
+  globalInfo(`Re-importing "${dir}" because file "${f}" ${reason}`);
+  return false;
+}
+function mismatchReason(target2, src2) {
+  try {
+    const targetStat = fs9.lstatSync(target2, { bigint: true });
+    if (!targetStat.isFile())
+      return "is not a regular file";
+    const srcStat = lib_default.statSync(src2, { bigint: true });
+    const hasSameFileIdentity = targetStat.ino !== 0n && targetStat.dev !== 0n && targetStat.ino === srcStat.ino && targetStat.dev === srcStat.dev;
+    if (hasSameFileIdentity)
+      return void 0;
+    if (targetStat.size !== srcStat.size)
+      return "has a different size";
+    if (!filesHaveEqualContents(target2, src2))
+      return "has different content";
+    return void 0;
+  } catch {
+    return "is missing or unreadable";
+  }
+}
+function filesHaveEqualContents(left, right) {
+  const leftBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
+  const rightBuffer = Buffer.allocUnsafe(FILE_COMPARE_BUFFER_SIZE);
+  const leftFd = fs9.openSync(left, "r");
+  try {
+    const rightFd = fs9.openSync(right, "r");
     try {
-      const targetStat = lib_default.statSync(target2);
-      const srcStat = lib_default.statSync(src2);
-      if (targetStat.ino === srcStat.ino && targetStat.dev === srcStat.dev)
-        continue;
-      if (targetStat.size !== srcStat.size) {
-        globalInfo(`Re-importing "${dir}" because file "${f}" has a different size`);
-        return false;
-      }
-      if (!lib_default.readFileSync(target2).equals(lib_default.readFileSync(src2))) {
-        globalInfo(`Re-importing "${dir}" because file "${f}" has different content`);
-        return false;
+      for (; ; ) {
+        const leftBytes = fs9.readSync(leftFd, leftBuffer, 0, leftBuffer.length, null);
+        const rightBytes = fs9.readSync(rightFd, rightBuffer, 0, rightBuffer.length, null);
+        if (leftBytes !== rightBytes)
+          return false;
+        if (leftBytes === 0)
+          return true;
+        if (!leftBuffer.subarray(0, leftBytes).equals(rightBuffer.subarray(0, rightBytes)))
+          return false;
       }
-    } catch {
-      globalInfo(`Re-importing "${dir}" because file "${f}" is missing or unreadable`);
-      return false;
+    } finally {
+      fs9.closeSync(rightFd);
     }
+  } finally {
+    fs9.closeSync(leftFd);
   }
-  return true;
 }
-function retryWithSanitizedFilenames(importer, newDir, filenames, opts2) {
+function retryWithSanitizedFilenames({ importer, newDir, filenames, opts: opts2 }) {
   const { sanitizedFilenames, invalidFilenames } = sanitizeFilenames(filenames);
   if (invalidFilenames.length === 0)
     return false;
@@ -8525,14 +8670,7 @@ function sanitizeFilenames(filenames) {
   return { sanitizedFilenames, invalidFilenames };
 }
 function tryImportIndexedDir({ importFile, importFileAtomic }, newDir, filenames) {
-  const allDirs = /* @__PURE__ */ new Set();
-  for (const f of filenames.keys()) {
-    const dir = path13.dirname(f);
-    if (dir === ".")
-      continue;
-    allDirs.add(dir);
-  }
-  Array.from(allDirs).sort((d1, d2) => d1.length - d2.length).forEach((dir) => fs9.mkdirSync(path13.join(newDir, dir), { recursive: true }));
+  makeFileMapDirs(newDir, filenames);
   let packageJsonSrc;
   for (const [f, src2] of filenames) {
     if (f === "package.json") {
@@ -8545,6 +8683,21 @@ function tryImportIndexedDir({ importFile, importFileAtomic }, newDir, filenames
     importFileAtomic(packageJsonSrc, path13.join(newDir, "package.json"));
   }
 }
+function makeFileMapDirs(newDir, filenames, opts2) {
+  const allDirs = /* @__PURE__ */ new Set();
+  for (const f of filenames.keys()) {
+    const dir = path13.dirname(f);
+    if (dir === ".")
+      continue;
+    allDirs.add(dir);
+  }
+  for (const dir of Array.from(allDirs).sort((d1, d2) => d1.length - d2.length)) {
+    if (opts2?.clearBlockers) {
+      clearDirentBlockingDir(newDir, dir);
+    }
+    fs9.mkdirSync(path13.join(newDir, dir), { recursive: true });
+  }
+}
 function getUniqueFileMap(fileMap) {
   const lowercaseFiles = /* @__PURE__ */ new Map();
   const conflictingFileNames = /* @__PURE__ */ new Map();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/exe",
-  "version": "11.20.0",
+  "version": "11.22.0",
   "description": "Fast, disk space efficient package manager",
   "keywords": [
     "pnpm",
@@ -35,19 +35,19 @@
     "detect-libc": "^2.1.2"
   },
   "optionalDependencies": {
-    "@pnpm/linux-arm64": "11.20.0",
-    "@pnpm/linux-x64": "11.20.0",
-    "@pnpm/linuxstatic-arm64": "11.20.0",
-    "@pnpm/linuxstatic-x64": "11.20.0",
-    "@pnpm/macos-arm64": "11.20.0",
-    "@pnpm/win-arm64": "11.20.0",
-    "@pnpm/win-x64": "11.20.0"
+    "@pnpm/linux-arm64": "11.22.0",
+    "@pnpm/linux-x64": "11.22.0",
+    "@pnpm/linuxstatic-arm64": "11.22.0",
+    "@pnpm/linuxstatic-x64": "11.22.0",
+    "@pnpm/macos-arm64": "11.22.0",
+    "@pnpm/win-arm64": "11.22.0",
+    "@pnpm/win-x64": "11.22.0"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/exe": "11.20.0",
+    "@pnpm/exe": "11.22.0",
     "@pnpm/jest-config": "1100.0.22",
-    "@zkochan/cmd-shim": "^9.0.6",
+    "@zkochan/cmd-shim": "^9.0.7",
     "execa": "npm:safe-execa@0.3.0"
   },
   "jest": {