@componentor/fs 1.2.4 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@componentor/fs",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "A blazing-fast, Node.js-compatible filesystem for the browser using OPFS",
   "type": "module",
   "main": "./dist/index.js",

package/src/handle-manager.ts

@@ -16,6 +16,70 @@ export interface GetHandleOptions {
 const FILE_HANDLE_POOL_SIZE = 50
 const DIR_CACHE_MAX_SIZE = 200
 
+/**
+ * Manages file-level locks to prevent concurrent sync access handle creation.
+ * OPFS only allows one sync access handle per file at a time.
+ */
+export class FileLockManager {
+  private locks: Map<string, Promise<void>> = new Map()
+  private lockResolvers: Map<string, () => void> = new Map()
+  private waitQueues: Map<string, Array<() => void>> = 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: string): Promise<() => void> {
+    const normalizedPath = normalize(path)
+
+    // If file is currently locked, wait for it
+    while (this.locks.has(normalizedPath)) {
+      await this.locks.get(normalizedPath)
+    }
+
+    // Create new lock
+    let resolve: () => void
+    const lockPromise = new Promise<void>(r => {
+      resolve = r
+    })
+
+    this.locks.set(normalizedPath, lockPromise)
+    this.lockResolvers.set(normalizedPath, resolve!)
+
+    // Return release function
+    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: string): boolean {
+    return this.locks.has(normalize(path))
+  }
+
+  /**
+   * Clear all locks (use with caution, mainly for cleanup)
+   */
+  clearAll(): void {
+    // Resolve all pending locks
+    for (const resolver of this.lockResolvers.values()) {
+      resolver()
+    }
+    this.locks.clear()
+    this.lockResolvers.clear()
+    this.waitQueues.clear()
+  }
+}
+
+// Global file lock manager instance
+export const fileLockManager = new FileLockManager()
+
 /**
  * Manages OPFS handles with caching for improved performance
  */

package/src/index.ts

@@ -24,7 +24,7 @@ import type {
 import { constants, flagsToString } from './constants.js'
 import { createENOENT, createEEXIST, createEACCES, createEISDIR, wrapError } from './errors.js'
 import { normalize, dirname, basename, join, isRoot, segments } from './path-utils.js'
-import { HandleManager } from './handle-manager.js'
+import { HandleManager, fileLockManager } from './handle-manager.js'
 import { SymlinkManager } from './symlink-manager.js'
 import { PackedStorage } from './packed-storage.js'
 import { createFileHandle } from './file-handle.js'
@@ -187,11 +187,19 @@ export default class OPFS {
         let buffer: Uint8Array
 
         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())
@@ -269,11 +277,19 @@ export default class OPFS {
 
               let buffer: Uint8Array
               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())
@@ -310,11 +326,19 @@ export default class OPFS {
       const buffer = typeof data === 'string' ? new TextEncoder().encode(data) : data
 
       if (this.useSync) {
-        const access = await fileHandle!.createSyncAccessHandle()
-        // Set exact size (more efficient than truncate(0) + write)
-        access.truncate(buffer.length)
-        access.write(buffer, { at: 0 })
-        access.close()
+        const releaseLock = await fileLockManager.acquire(resolvedPath)
+        try {
+          const access = await fileHandle!.createSyncAccessHandle()
+          try {
+            // Set exact size (more efficient than truncate(0) + write)
+            access.truncate(buffer.length)
+            access.write(buffer, { at: 0 })
+          } finally {
+            access.close()
+          }
+        } finally {
+          releaseLock()
+        }
       } else {
         const writable = await fileHandle!.createWritable()
         await writable.write(buffer)
@@ -1036,9 +1060,17 @@ export default class OPFS {
       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())