@rushstack/package-extractor 0.12.8 → 0.12.10

package/CHANGELOG.json

@@ -1,6 +1,45 @@
 {
   "name": "@rushstack/package-extractor",
   "entries": [
+    {
+      "version": "0.12.10",
+      "tag": "@rushstack/package-extractor_v0.12.10",
+      "date": "Tue, 31 Mar 2026 15:14:15 GMT",
+      "comments": {
+        "dependency": [
+          {
+            "comment": "Updating dependency \"@rushstack/node-core-library\" to `5.21.0`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/terminal\" to `0.22.4`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/ts-command-line\" to `5.3.4`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/heft-webpack5-plugin\" to `1.3.8`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/heft\" to `1.2.8`"
+          },
+          {
+            "comment": "Updating dependency \"@rushstack/webpack-preserve-dynamic-require-plugin\" to `0.12.9`"
+          }
+        ]
+      }
+    },
+    {
+      "version": "0.12.9",
+      "tag": "@rushstack/package-extractor_v0.12.9",
+      "date": "Wed, 25 Mar 2026 01:00:26 GMT",
+      "comments": {
+        "patch": [
+          {
+            "comment": "preventing duplicate-copy conflicts across npm-packlist versions"
+          }
+        ]
+      }
+    },
     {
       "version": "0.12.8",
       "tag": "@rushstack/package-extractor_v0.12.8",

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Change Log - @rushstack/package-extractor
 
-This log was last generated on Mon, 09 Mar 2026 15:14:08 GMT and should not be manually modified.
+This log was last generated on Tue, 31 Mar 2026 15:14:15 GMT and should not be manually modified.
+
+## 0.12.10
+Tue, 31 Mar 2026 15:14:15 GMT
+
+_Version update only_
+
+## 0.12.9
+Wed, 25 Mar 2026 01:00:26 GMT
+
+### Patches
+
+- preventing duplicate-copy conflicts across npm-packlist versions
 
 ## 0.12.8
 Mon, 09 Mar 2026 15:14:08 GMT

package/dist/scripts/create-links.js

@@ -58596,9 +58596,12 @@ class LockFile {
      * Attempts to acquire the lock on a Linux or OSX machine
      */
     static _tryAcquireMacOrLinux(resourceFolder, resourceName, pidLockFilePath) {
-        let dirtyWhenAcquired = false;
-        // get the current process' pid
+        // get the current process identifier (PID)
         const pid = process.pid;
+        // Suppose that a process terminates unexpectedly without deleting its PID-based lockfile,
+        // then we check to see if the process is still alive.  The OS may have given the same PID
+        // to a new process, how to detect that?  We will rely on getProcessStartTime() which
+        // is stored in the file itself for comparison.
         const startTime = LockFile._getStartTime(pid);
         if (!startTime) {
             throw new Error(`Unable to calculate start time for current process.`);
@@ -58618,17 +58621,23 @@ class LockFile {
             const files = FileSystem_1.FileSystem.readFolderItemNames(resourceFolder);
             // look for anything ending with # then numbers and ".lock"
             const lockFileRegExp = /^(.+)#([0-9]+)\.lock$/;
+            // If we are the process to acquire the lock, it becomes our responsibility to clean up these
+            // stale files.  If there is at least 1 stale file, then the resource is assumed to be "dirty"
+            // (for example, the previous process was interrupted before releasing or while acquiring).
+            const staleFilesToDelete = [];
             let match;
             let otherPid;
             for (const fileInFolder of files) {
                 if ((match = fileInFolder.match(lockFileRegExp)) &&
                     match[1] === resourceName &&
                     (otherPid = match[2]) !== pid.toString()) {
-                    // we found at least one lockfile hanging around that isn't ours
+                    // We found at least one lockfile hanging around that isn't ours
                     const fileInFolderPath = `${resourceFolder}/${fileInFolder}`;
-                    dirtyWhenAcquired = true;
                     // console.log(`FOUND OTHER LOCKFILE: ${otherPid}`);
+                    // Actual start time of the other PID
                     const otherPidCurrentStartTime = LockFile._getStartTime(parseInt(otherPid, 10));
+                    // The start time from the file, which we will compare with otherPidCurrentStartTime
+                    // to determine whether the PID got reused by a new process.
                     let otherPidOldStartTime;
                     let otherBirthtimeMs;
                     try {
@@ -58638,41 +58647,53 @@ class LockFile {
                     }
                     catch (error) {
                         if (FileSystem_1.FileSystem.isNotExistError(error)) {
-                            // the file is already deleted by other process, skip it
+                            // ==> Properly closed lockfile, safe to ignore:
+                            // The other process deleted the file, which we assume means it completed successfully,
+                            // so the state is not dirty.  This is equivalent to if readFolderItemNames() never saw
+                            // the file in the firstplace.
                             continue;
                         }
                     }
-                    // if the otherPidOldStartTime is invalid, then we should look at the timestamp,
-                    // if this file was created after us, ignore it
-                    // if it was created within 1 second before us, then it could be good, so we
-                    //  will conservatively fail
-                    // otherwise it is an old lock file and will be deleted
-                    if (otherPidOldStartTime === '' && otherBirthtimeMs !== undefined) {
+                    // What the other process's file exists, but it is an empty file?
+                    // Either they were terminated while acquiring, or else they haven't finished writing it yet.
+                    if (otherBirthtimeMs !== undefined && otherPidOldStartTime === '') {
                         if (otherBirthtimeMs > currentBirthTimeMs) {
-                            // ignore this file, he will be unable to get the lock since this process
-                            // will hold it
+                            // ==> Safe to ignore
+                            // If the other process was terminated, it happened before they finished acquiring.
+                            // If the other process is alive, their file is newer, so we will acquire instead of them.
                             // console.log(`Ignoring lock for pid ${otherPid} because its lockfile is newer than ours.`);
                             continue;
                         }
-                        else if (otherBirthtimeMs - currentBirthTimeMs < 0 && // it was created before us AND
+                        else if (otherBirthtimeMs - currentBirthTimeMs < 0 &&
                             otherBirthtimeMs - currentBirthTimeMs > -1000) {
-                            // it was created less than a second before
-                            // conservatively be unable to keep the lock
-                            return undefined;
+                            // ==> Race condition
+                            // The other process created their file first, so they will probably acquire the lock
+                            // after they finish writing the contents.  But what if their process is actually dead
+                            // and replaced by a new process with the same PID?  Normally the otherPidOldStartTime
+                            // gives the answer, but in this edge case we are missing that information.
+                            // So we conservatively assume that it should not take them more than 1000ms to
+                            // open a file, write a PID, and close the file.
+                            return undefined; // fail to acquire and retry later
                         }
                     }
                     // console.log(`Other pid ${otherPid} lockfile has start time: "${otherPidOldStartTime}"`);
                     // console.log(`Other pid ${otherPid} actually has start time: "${otherPidCurrentStartTime}"`);
-                    // this means the process is no longer executing, delete the file
+                    // Time to compare
                     if (!otherPidCurrentStartTime || otherPidOldStartTime !== otherPidCurrentStartTime) {
+                        // ==> Stale lockfile
+                        // This file doesn't prevent us from acquiring the lock, but it does indicate that
+                        // the resource was left in a dirty state.  (If we delete the file right now, that
+                        // information would be lost, so we clean up later when we acquire successfully.)
                         // console.log(`Other pid ${otherPid} is no longer executing!`);
-                        FileSystem_1.FileSystem.deleteFile(fileInFolderPath);
+                        staleFilesToDelete.push(fileInFolderPath);
                         continue;
                     }
                     // console.log(`Pid ${otherPid} lockfile has birth time: ${otherBirthtimeMs}`);
                     // console.log(`Pid ${pid} lockfile has birth time: ${currentBirthTimeMs}`);
-                    // this is a lockfile pointing at something valid
                     if (otherBirthtimeMs !== undefined) {
+                        // ==> We found a valid file belonging to another process.
+                        // With multiple parties trying to acquire, the winner is the smallestBirthTime,
+                        // so we need to sort.
                         // the other lock file was created before the current earliest lock file
                         // or the other lock file was created at the same exact time, but has earlier pid
                         // note that it is acceptable to do a direct comparison of the PIDs in this case
@@ -58693,9 +58714,14 @@ class LockFile {
                 // we do not have the lock
                 return undefined;
             }
-            // we have the lock!
+            let dirtyWhenAcquired = false;
+            for (const staleFileToDelete of staleFilesToDelete) {
+                FileSystem_1.FileSystem.deleteFile(staleFileToDelete, { throwIfNotExists: false });
+                dirtyWhenAcquired = true;
+            }
+            // We have the lock!
             lockFile = new LockFile(lockFileHandle, pidLockFilePath, dirtyWhenAcquired);
-            lockFileHandle = undefined; // we have handed the descriptor off to the instance
+            lockFileHandle = undefined; // The LockFile object has taken ownership of our handle
         }
         finally {
             if (lockFileHandle) {