@componentor/fs 1.2.3 → 1.2.5

package/dist/index.js

@@ -145,6 +145,52 @@ function segments(path) {
 // src/handle-manager.ts
 var FILE_HANDLE_POOL_SIZE = 50;
 var DIR_CACHE_MAX_SIZE = 200;
+var FileLockManager = class {
+  locks = /* @__PURE__ */ new Map();
+  lockResolvers = /* @__PURE__ */ new Map();
+  waitQueues = /* @__PURE__ */ new Map();
+  /**
+   * Acquire an exclusive lock on a file path.
+   * If the file is already locked, waits until it's released.
+   * Returns a release function that MUST be called when done.
+   */
+  async acquire(path) {
+    const normalizedPath = normalize(path);
+    while (this.locks.has(normalizedPath)) {
+      await this.locks.get(normalizedPath);
+    }
+    let resolve;
+    const lockPromise = new Promise((r) => {
+      resolve = r;
+    });
+    this.locks.set(normalizedPath, lockPromise);
+    this.lockResolvers.set(normalizedPath, resolve);
+    return () => {
+      const resolver = this.lockResolvers.get(normalizedPath);
+      this.locks.delete(normalizedPath);
+      this.lockResolvers.delete(normalizedPath);
+      if (resolver) resolver();
+    };
+  }
+  /**
+   * Check if a file is currently locked
+   */
+  isLocked(path) {
+    return this.locks.has(normalize(path));
+  }
+  /**
+   * Clear all locks (use with caution, mainly for cleanup)
+   */
+  clearAll() {
+    for (const resolver of this.lockResolvers.values()) {
+      resolver();
+    }
+    this.locks.clear();
+    this.lockResolvers.clear();
+    this.waitQueues.clear();
+  }
+};
+var fileLockManager = new FileLockManager();
 var HandleManager = class {
   rootPromise;
   dirCache = /* @__PURE__ */ new Map();
@@ -402,13 +448,21 @@ var SymlinkManager = class {
     if (!fileHandle) return;
     const buffer = new TextEncoder().encode(data);
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle();
-      access.truncate(0);
-      let written = 0;
-      while (written < buffer.length) {
-        written += access.write(buffer.subarray(written), { at: written });
+      const releaseLock = await fileLockManager.acquire(SYMLINK_FILE);
+      try {
+        const access = await fileHandle.createSyncAccessHandle();
+        try {
+          access.truncate(0);
+          let written = 0;
+          while (written < buffer.length) {
+            written += access.write(buffer.subarray(written), { at: written });
+          }
+        } finally {
+          access.close();
+        }
+      } finally {
+        releaseLock();
       }
-      access.close();
     } else {
       const writable = await fileHandle.createWritable();
       await writable.write(buffer);
@@ -681,6 +735,7 @@ var PackedStorage = class {
   /**
    * Load pack index from disk (always reloads to support hybrid mode)
    * Verifies CRC32 checksum for integrity
+   * Note: Caller must hold the lock
    */
   async loadIndex() {
     try {
@@ -689,29 +744,36 @@ var PackedStorage = class {
         return {};
       }
       if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle();
-        const size = access.getSize();
-        if (size < 8) {
-          access.close();
-          return {};
-        }
-        const header = new Uint8Array(8);
-        access.read(header, { at: 0 });
-        const view = new DataView(header.buffer);
-        const indexLen = view.getUint32(0, true);
-        const storedCrc = view.getUint32(4, true);
-        const contentSize = size - 8;
-        const content = new Uint8Array(contentSize);
-        access.read(content, { at: 8 });
-        access.close();
-        if (this.useChecksum && storedCrc !== 0) {
-          const calculatedCrc = crc32(content);
-          if (calculatedCrc !== storedCrc) {
-            throw createECORRUPTED(PACK_FILE);
+        const releaseLock = await fileLockManager.acquire(PACK_FILE);
+        try {
+          const access = await fileHandle.createSyncAccessHandle();
+          try {
+            const size = access.getSize();
+            if (size < 8) {
+              return {};
+            }
+            const header = new Uint8Array(8);
+            access.read(header, { at: 0 });
+            const view = new DataView(header.buffer);
+            const indexLen = view.getUint32(0, true);
+            const storedCrc = view.getUint32(4, true);
+            const contentSize = size - 8;
+            const content = new Uint8Array(contentSize);
+            access.read(content, { at: 8 });
+            if (this.useChecksum && storedCrc !== 0) {
+              const calculatedCrc = crc32(content);
+              if (calculatedCrc !== storedCrc) {
+                throw createECORRUPTED(PACK_FILE);
+              }
+            }
+            const indexJson = new TextDecoder().decode(content.subarray(0, indexLen));
+            return JSON.parse(indexJson);
+          } finally {
+            access.close();
           }
+        } finally {
+          releaseLock();
         }
-        const indexJson = new TextDecoder().decode(content.subarray(0, indexLen));
-        return JSON.parse(indexJson);
       } else {
         const file = await fileHandle.getFile();
         const data = new Uint8Array(await file.arrayBuffer());
@@ -764,10 +826,18 @@ var PackedStorage = class {
     if (!fileHandle) return null;
     let buffer;
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle();
-      buffer = new Uint8Array(entry.size);
-      access.read(buffer, { at: entry.offset });
-      access.close();
+      const releaseLock = await fileLockManager.acquire(PACK_FILE);
+      try {
+        const access = await fileHandle.createSyncAccessHandle();
+        try {
+          buffer = new Uint8Array(entry.size);
+          access.read(buffer, { at: entry.offset });
+        } finally {
+          access.close();
+        }
+      } finally {
+        releaseLock();
+      }
     } else {
       const file = await fileHandle.getFile();
       const data = new Uint8Array(await file.arrayBuffer());
@@ -806,17 +876,25 @@ var PackedStorage = class {
     }
     const decompressPromises = [];
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle();
-      for (const { path, offset, size, originalSize } of toRead) {
-        const buffer = new Uint8Array(size);
-        access.read(buffer, { at: offset });
-        if (originalSize !== void 0) {
-          decompressPromises.push({ path, promise: decompress(buffer) });
-        } else {
-          results.set(path, buffer);
+      const releaseLock = await fileLockManager.acquire(PACK_FILE);
+      try {
+        const access = await fileHandle.createSyncAccessHandle();
+        try {
+          for (const { path, offset, size, originalSize } of toRead) {
+            const buffer = new Uint8Array(size);
+            access.read(buffer, { at: offset });
+            if (originalSize !== void 0) {
+              decompressPromises.push({ path, promise: decompress(buffer) });
+            } else {
+              results.set(path, buffer);
+            }
+          }
+        } finally {
+          access.close();
         }
+      } finally {
+        releaseLock();
       }
-      access.close();
     } else {
       const file = await fileHandle.getFile();
       const data = new Uint8Array(await file.arrayBuffer());
@@ -897,15 +975,24 @@ var PackedStorage = class {
   }
   /**
    * Write the pack file to OPFS
+   * Note: Caller must hold the lock
    */
   async writePackFile(data) {
     const { fileHandle } = await this.handleManager.getHandle(PACK_FILE, { create: true });
     if (!fileHandle) return;
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle();
-      access.truncate(data.length);
-      access.write(data, { at: 0 });
-      access.close();
+      const releaseLock = await fileLockManager.acquire(PACK_FILE);
+      try {
+        const access = await fileHandle.createSyncAccessHandle();
+        try {
+          access.truncate(data.length);
+          access.write(data, { at: 0 });
+        } finally {
+          access.close();
+        }
+      } finally {
+        releaseLock();
+      }
     } else {
       const writable = await fileHandle.createWritable();
       await writable.write(data);
@@ -925,33 +1012,41 @@ var PackedStorage = class {
     const encoder = new TextEncoder();
     const newIndexBuf = encoder.encode(JSON.stringify(index));
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle();
-      const size = access.getSize();
-      const oldHeader = new Uint8Array(8);
-      access.read(oldHeader, { at: 0 });
-      const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true);
-      const dataStart = 8 + oldIndexLen;
-      const dataSize = size - dataStart;
-      const dataPortion = new Uint8Array(dataSize);
-      if (dataSize > 0) {
-        access.read(dataPortion, { at: dataStart });
-      }
-      const newContent = new Uint8Array(newIndexBuf.length + dataSize);
-      newContent.set(newIndexBuf, 0);
-      if (dataSize > 0) {
-        newContent.set(dataPortion, newIndexBuf.length);
+      const releaseLock = await fileLockManager.acquire(PACK_FILE);
+      try {
+        const access = await fileHandle.createSyncAccessHandle();
+        try {
+          const size = access.getSize();
+          const oldHeader = new Uint8Array(8);
+          access.read(oldHeader, { at: 0 });
+          const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true);
+          const dataStart = 8 + oldIndexLen;
+          const dataSize = size - dataStart;
+          const dataPortion = new Uint8Array(dataSize);
+          if (dataSize > 0) {
+            access.read(dataPortion, { at: dataStart });
+          }
+          const newContent = new Uint8Array(newIndexBuf.length + dataSize);
+          newContent.set(newIndexBuf, 0);
+          if (dataSize > 0) {
+            newContent.set(dataPortion, newIndexBuf.length);
+          }
+          const checksum = this.useChecksum ? crc32(newContent) : 0;
+          const newHeader = new Uint8Array(8);
+          const view = new DataView(newHeader.buffer);
+          view.setUint32(0, newIndexBuf.length, true);
+          view.setUint32(4, checksum, true);
+          const newFile = new Uint8Array(8 + newContent.length);
+          newFile.set(newHeader, 0);
+          newFile.set(newContent, 8);
+          access.truncate(newFile.length);
+          access.write(newFile, { at: 0 });
+        } finally {
+          access.close();
+        }
+      } finally {
+        releaseLock();
       }
-      const checksum = this.useChecksum ? crc32(newContent) : 0;
-      const newHeader = new Uint8Array(8);
-      const view = new DataView(newHeader.buffer);
-      view.setUint32(0, newIndexBuf.length, true);
-      view.setUint32(4, checksum, true);
-      const newFile = new Uint8Array(8 + newContent.length);
-      newFile.set(newHeader, 0);
-      newFile.set(newContent, 8);
-      access.truncate(newFile.length);
-      access.write(newFile, { at: 0 });
-      access.close();
     } else {
       const file = await fileHandle.getFile();
       const oldData = new Uint8Array(await file.arrayBuffer());
@@ -1621,11 +1716,19 @@ var OPFS = class {
       if (fileHandle) {
         let buffer;
         if (this.useSync) {
-          const access = await fileHandle.createSyncAccessHandle();
-          const size = access.getSize();
-          buffer = new Uint8Array(size);
-          access.read(buffer);
-          access.close();
+          const releaseLock = await fileLockManager.acquire(resolvedPath);
+          try {
+            const access = await fileHandle.createSyncAccessHandle();
+            try {
+              const size = access.getSize();
+              buffer = new Uint8Array(size);
+              access.read(buffer);
+            } finally {
+              access.close();
+            }
+          } finally {
+            releaseLock();
+          }
         } else {
           const file = await fileHandle.getFile();
           buffer = new Uint8Array(await file.arrayBuffer());
@@ -1682,11 +1785,19 @@ var OPFS = class {
               }
               let buffer;
               if (this.useSync) {
-                const access = await fileHandle.createSyncAccessHandle();
-                const size = access.getSize();
-                buffer = new Uint8Array(size);
-                access.read(buffer);
-                access.close();
+                const releaseLock = await fileLockManager.acquire(resolvedPath);
+                try {
+                  const access = await fileHandle.createSyncAccessHandle();
+                  try {
+                    const size = access.getSize();
+                    buffer = new Uint8Array(size);
+                    access.read(buffer);
+                  } finally {
+                    access.close();
+                  }
+                } finally {
+                  releaseLock();
+                }
               } else {
                 const file = await fileHandle.getFile();
                 buffer = new Uint8Array(await file.arrayBuffer());
@@ -1718,10 +1829,18 @@ var OPFS = class {
       const { fileHandle } = await this.handleManager.getHandle(resolvedPath, { create: true });
       const buffer = typeof data === "string" ? new TextEncoder().encode(data) : data;
       if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle();
-        access.truncate(buffer.length);
-        access.write(buffer, { at: 0 });
-        access.close();
+        const releaseLock = await fileLockManager.acquire(resolvedPath);
+        try {
+          const access = await fileHandle.createSyncAccessHandle();
+          try {
+            access.truncate(buffer.length);
+            access.write(buffer, { at: 0 });
+          } finally {
+            access.close();
+          }
+        } finally {
+          releaseLock();
+        }
       } else {
         const writable = await fileHandle.createWritable();
         await writable.write(buffer);
@@ -2334,9 +2453,17 @@ var OPFS = class {
       const { fileHandle } = await this.handleManager.getHandle(resolvedPath);
       if (!fileHandle) throw createENOENT(path);
       if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle();
-        access.truncate(len);
-        access.close();
+        const releaseLock = await fileLockManager.acquire(resolvedPath);
+        try {
+          const access = await fileHandle.createSyncAccessHandle();
+          try {
+            access.truncate(len);
+          } finally {
+            access.close();
+          }
+        } finally {
+          releaseLock();
+        }
       } else {
         const file = await fileHandle.getFile();
         const data = new Uint8Array(await file.arrayBuffer());