@pnpm/fs.graceful-fs 1100.2.3 → 1100.2.5

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @pnpm/fs.graceful-fs
 
+## 1100.2.5
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/error@1100.2.2
+
+## 1100.2.4
+
+### Patch Changes
+
+- Fixed concurrent installs failing when replacing the same stale hoisted dependency link.
+
+- `pnpm install` now works in StackBlitz WebContainers on projects without a lockfile. It used to fail there with `ENOENT ... pnpm-lock.yaml`, because pnpm did not recognize the errors that WebContainers return from asynchronous file system calls [#15649](https://github.com/pnpm/pnpm/issues/15649).
+
+- Updated dependencies:
+  - @pnpm/error@1100.2.1
+
 ## 1100.2.3
 
 ### Patch Changes

package/lib/index.d.ts

@@ -55,4 +55,10 @@ export declare function unlinkWithRetry(target: string): void;
  * Runs a filesystem operation with the retry policy of
  * {@link renameFileWithRetry}.
  */
-export declare function withFileLockRetry<T>(operation: () => T): T;
+export declare function withFileLockRetry<Result>(operation: () => Result): Result;
+/**
+ * Asynchronous {@link withFileLockRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export declare function withFileLockRetryAsync<Result>(operation: () => Promise<Result>): Promise<Result>;
+export declare function isTransientFileLockError(err: unknown): err is NodeJS.ErrnoException;

package/lib/index.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import os from 'node:os';
-import util, { promisify } from 'node:util';
+import { promisify } from 'node:util';
+import { isError } from '@pnpm/error';
 import gfs from 'graceful-fs';
 const FILE_LOCK_RETRY_BUDGET_MS = 60_000;
 const PERMISSION_DENIED_RETRY_BUDGET_MS = 1_000;
@@ -30,23 +31,33 @@ function withEagainRetry(fn, maxRetries = 15) {
     return (...args) => {
         let attempts = 0;
         while (attempts <= maxRetries) {
-            try {
-                return fn(...args);
-            }
-            catch (err) {
-                if (util.types.isNativeError(err) && 'code' in err && err.code === 'EAGAIN' && attempts < maxRetries) {
-                    attempts++;
-                    // Exponential backoff: wait 2^attempts milliseconds, max 300ms
-                    const delay = Math.min(Math.pow(2, attempts), 300);
-                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
-                    continue;
-                }
-                throw err;
-            }
+            const outcome = tryCallWithEagain(fn, args, attempts, maxRetries);
+            if (outcome.success)
+                return outcome.value;
+            attempts = outcome.attempts;
         }
         throw new Error('Unreachable');
     };
 }
+function tryCallWithEagain(fn, args, attempts, maxRetries) {
+    try {
+        return { success: true, value: fn(...args) };
+    }
+    catch (err) {
+        if (!isEagainError(err) || attempts >= maxRetries)
+            throw err;
+        const nextAttempts = attempts + 1;
+        waitEagainBackoff(nextAttempts);
+        return { success: false, attempts: nextAttempts };
+    }
+}
+function isEagainError(err) {
+    return isError(err) && 'code' in err && err.code === 'EAGAIN';
+}
+function waitEagainBackoff(attempts) {
+    const delay = Math.min(Math.pow(2, attempts), 300);
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delay);
+}
 /**
  * Renames `src` over `dest`, retrying Windows EBUSY errors for up to a minute.
  * Windows drives mounted into WSL get the same retries.
@@ -108,23 +119,30 @@ export function withFileLockRetry(operation) {
         }
     }
 }
-async function withFileLockRetryAsync(operation) {
+/**
+ * Asynchronous {@link withFileLockRetry}, which waits between attempts
+ * without blocking the event loop.
+ */
+export async function withFileLockRetryAsync(operation) {
     const retry = createFileLockRetry();
     for (;;) {
         try {
-            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line no-await-in-loop -- the next attempt runs only after this one fails
             return await operation();
         }
         catch (err) {
-            const delayMs = retry.delayBeforeNextAttempt(err);
-            if (delayMs > 0) {
-                // eslint-disable-next-line no-await-in-loop
-                await new Promise((resolve) => setTimeout(resolve, delayMs));
-            }
-            retry.checkBudgetAfterDelay(err);
+            // eslint-disable-next-line no-await-in-loop -- backs off before the next attempt
+            await backOffWithFileLockRetryAsync(retry, err);
         }
     }
 }
+async function backOffWithFileLockRetryAsync(retry, err) {
+    const delayMs = retry.delayBeforeNextAttempt(err);
+    if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+    retry.checkBudgetAfterDelay(err);
+}
 function createFileLockRetry() {
     const startedAt = Date.now();
     let backoffMs = 0;
@@ -147,9 +165,9 @@ function createFileLockRetry() {
         },
     };
 }
-function isTransientFileLockError(err) {
+export function isTransientFileLockError(err) {
     return (process.platform === 'win32' || isWsl()) &&
-        util.types.isNativeError(err) &&
+        isError(err) &&
         'code' in err &&
         (err.code === 'EPERM' || err.code === 'EACCES' || err.code === 'EBUSY');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/fs.graceful-fs",
-  "version": "1100.2.3",
+  "version": "1100.2.5",
   "description": "Promisified graceful-fs",
   "keywords": [
     "pnpm",
@@ -27,11 +27,12 @@
     "!*.map"
   ],
   "dependencies": {
+    "@pnpm/error": "1100.2.2",
     "graceful-fs": "^4.2.11"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/fs.graceful-fs": "1100.2.3",
+    "@pnpm/fs.graceful-fs": "1100.2.5",
     "@types/graceful-fs": "^4.1.9"
   },
   "engines": {