@componentor/fs 1.2.4 → 1.2.5

package/src/packed-storage.ts

@@ -15,6 +15,7 @@
  */
 
 import type { HandleManager } from './handle-manager.js'
+import { fileLockManager } from './handle-manager.js'
 import { createECORRUPTED } from './errors.js'
 
 // ============ Compression ============
@@ -128,7 +129,6 @@ export class PackedStorage {
   private useChecksum: boolean
   private index: PackIndex | null = null
   private indexLoaded = false
-  private lockPromise: Promise<void> | null = null
 
   constructor(handleManager: HandleManager, useSync: boolean, useCompression = false, useChecksum = true) {
     this.handleManager = handleManager
@@ -138,23 +138,6 @@ export class PackedStorage {
     this.useChecksum = useChecksum
   }
 
-  /**
-   * Acquire lock for pack file access (prevents concurrent handle conflicts)
-   */
-  private async acquireLock(): Promise<() => void> {
-    while (this.lockPromise) {
-      await this.lockPromise
-    }
-    let release: () => void
-    this.lockPromise = new Promise(resolve => {
-      release = () => {
-        this.lockPromise = null
-        resolve()
-      }
-    })
-    return release!
-  }
-
   /**
    * Reset pack storage state (memory only)
    */
@@ -191,38 +174,43 @@ export class PackedStorage {
       }
 
       if (this.useSync) {
-        const access = await fileHandle.createSyncAccessHandle()
+        const releaseLock = await fileLockManager.acquire(PACK_FILE)
         try {
-          const size = access.getSize()
-          if (size < 8) {
-            return {}
-          }
+          const access = await fileHandle.createSyncAccessHandle()
+          try {
+            const size = access.getSize()
+            if (size < 8) {
+              return {}
+            }
 
-          // Read header: index length + CRC32
-          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)
-
-          // Read everything after header (index + data) for CRC verification
-          const contentSize = size - 8
-          const content = new Uint8Array(contentSize)
-          access.read(content, { at: 8 })
-
-          // Verify CRC32 if enabled
-          if (this.useChecksum && storedCrc !== 0) {
-            const calculatedCrc = crc32(content)
-            if (calculatedCrc !== storedCrc) {
-              throw createECORRUPTED(PACK_FILE)
+            // Read header: index length + CRC32
+            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)
+
+            // Read everything after header (index + data) for CRC verification
+            const contentSize = size - 8
+            const content = new Uint8Array(contentSize)
+            access.read(content, { at: 8 })
+
+            // Verify CRC32 if enabled
+            if (this.useChecksum && storedCrc !== 0) {
+              const calculatedCrc = crc32(content)
+              if (calculatedCrc !== storedCrc) {
+                throw createECORRUPTED(PACK_FILE)
+              }
             }
-          }
 
-          // Parse index from content
-          const indexJson = new TextDecoder().decode(content.subarray(0, indexLen))
-          return JSON.parse(indexJson)
+            // Parse index from content
+            const indexJson = new TextDecoder().decode(content.subarray(0, indexLen))
+            return JSON.parse(indexJson)
+          } finally {
+            access.close()
+          }
         } finally {
-          access.close()
+          releaseLock()
         }
       } else {
         const file = await fileHandle.getFile()
@@ -256,13 +244,8 @@ export class PackedStorage {
    * Check if a path exists in the pack
    */
   async has(path: string): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      return path in index
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    return path in index
   }
 
   /**
@@ -270,15 +253,10 @@ export class PackedStorage {
    * Returns originalSize if compressed, otherwise size
    */
   async getSize(path: string): Promise<number | null> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      const entry = index[path]
-      if (!entry) return null
-      return entry.originalSize ?? entry.size
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    const entry = index[path]
+    if (!entry) return null
+    return entry.originalSize ?? entry.size
   }
 
   /**
@@ -286,18 +264,18 @@ export class PackedStorage {
    * Handles decompression if file was stored compressed
    */
   async read(path: string): Promise<Uint8Array | null> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      const entry = index[path]
-      if (!entry) return null
+    const index = await this.loadIndex()
+    const entry = index[path]
+    if (!entry) return null
 
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) return null
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) return null
 
-      let buffer: Uint8Array
+    let buffer: Uint8Array
 
-      if (this.useSync) {
+    if (this.useSync) {
+      const releaseLock = await fileLockManager.acquire(PACK_FILE)
+      try {
         const access = await fileHandle.createSyncAccessHandle()
         try {
           buffer = new Uint8Array(entry.size)
@@ -305,21 +283,21 @@ export class PackedStorage {
         } finally {
           access.close()
         }
-      } else {
-        const file = await fileHandle.getFile()
-        const data = new Uint8Array(await file.arrayBuffer())
-        buffer = data.slice(entry.offset, entry.offset + entry.size)
-      }
-
-      // Decompress if needed
-      if (entry.originalSize !== undefined) {
-        return decompress(buffer)
+      } finally {
+        releaseLock()
       }
+    } else {
+      const file = await fileHandle.getFile()
+      const data = new Uint8Array(await file.arrayBuffer())
+      buffer = data.slice(entry.offset, entry.offset + entry.size)
+    }
 
-      return buffer
-    } finally {
-      release()
+    // Decompress if needed
+    if (entry.originalSize !== undefined) {
+      return decompress(buffer)
     }
+
+    return buffer
   }
 
   /**
@@ -331,35 +309,35 @@ export class PackedStorage {
     const results = new Map<string, Uint8Array | null>()
     if (paths.length === 0) return results
 
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-
-      // Find which paths are in the pack
-      const toRead: Array<{ path: string; offset: number; size: number; originalSize?: number }> = []
-      for (const path of paths) {
-        const entry = index[path]
-        if (entry) {
-          toRead.push({ path, offset: entry.offset, size: entry.size, originalSize: entry.originalSize })
-        } else {
-          results.set(path, null)
-        }
+    const index = await this.loadIndex()
+
+    // Find which paths are in the pack
+    const toRead: Array<{ path: string; offset: number; size: number; originalSize?: number }> = []
+    for (const path of paths) {
+      const entry = index[path]
+      if (entry) {
+        toRead.push({ path, offset: entry.offset, size: entry.size, originalSize: entry.originalSize })
+      } else {
+        results.set(path, null)
       }
+    }
 
-      if (toRead.length === 0) return results
+    if (toRead.length === 0) return results
 
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) {
-        for (const { path } of toRead) {
-          results.set(path, null)
-        }
-        return results
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) {
+      for (const { path } of toRead) {
+        results.set(path, null)
       }
+      return results
+    }
 
-      // Read all files
-      const decompressPromises: Array<{ path: string; promise: Promise<Uint8Array> }> = []
+    // Read all files
+    const decompressPromises: Array<{ path: string; promise: Promise<Uint8Array> }> = []
 
-      if (this.useSync) {
+    if (this.useSync) {
+      const releaseLock = await fileLockManager.acquire(PACK_FILE)
+      try {
         const access = await fileHandle.createSyncAccessHandle()
         try {
           for (const { path, offset, size, originalSize } of toRead) {
@@ -376,29 +354,29 @@ export class PackedStorage {
         } finally {
           access.close()
         }
-      } else {
-        const file = await fileHandle.getFile()
-        const data = new Uint8Array(await file.arrayBuffer())
-        for (const { path, offset, size, originalSize } of toRead) {
-          const buffer = data.slice(offset, offset + size)
-
-          if (originalSize !== undefined) {
-            decompressPromises.push({ path, promise: decompress(buffer) })
-          } else {
-            results.set(path, buffer)
-          }
-        }
+      } finally {
+        releaseLock()
       }
+    } else {
+      const file = await fileHandle.getFile()
+      const data = new Uint8Array(await file.arrayBuffer())
+      for (const { path, offset, size, originalSize } of toRead) {
+        const buffer = data.slice(offset, offset + size)
 
-      // Wait for all decompressions
-      for (const { path, promise } of decompressPromises) {
-        results.set(path, await promise)
+        if (originalSize !== undefined) {
+          decompressPromises.push({ path, promise: decompress(buffer) })
+        } else {
+          results.set(path, buffer)
+        }
       }
+    }
 
-      return results
-    } finally {
-      release()
+    // Wait for all decompressions
+    for (const { path, promise } of decompressPromises) {
+      results.set(path, await promise)
     }
+
+    return results
   }
 
   /**
@@ -411,86 +389,81 @@ export class PackedStorage {
   async writeBatch(entries: Array<{ path: string; data: Uint8Array }>): Promise<void> {
     if (entries.length === 0) return
 
-    const release = await this.acquireLock()
-    try {
-      const encoder = new TextEncoder()
-
-      // Compress data if enabled
-      let processedEntries: Array<{ path: string; data: Uint8Array; originalSize?: number }>
-      if (this.useCompression) {
-        processedEntries = await Promise.all(
-          entries.map(async ({ path, data }) => {
-            const compressed = await compress(data)
-            // Only use compressed if it's actually smaller
-            if (compressed.length < data.length) {
-              return { path, data: compressed, originalSize: data.length }
-            }
-            return { path, data }
-          })
-        )
-      } else {
-        processedEntries = entries
-      }
+    const encoder = new TextEncoder()
+
+    // Compress data if enabled
+    let processedEntries: Array<{ path: string; data: Uint8Array; originalSize?: number }>
+    if (this.useCompression) {
+      processedEntries = await Promise.all(
+        entries.map(async ({ path, data }) => {
+          const compressed = await compress(data)
+          // Only use compressed if it's actually smaller
+          if (compressed.length < data.length) {
+            return { path, data: compressed, originalSize: data.length }
+          }
+          return { path, data }
+        })
+      )
+    } else {
+      processedEntries = entries
+    }
 
-      // Calculate total data size (using compressed sizes where applicable)
-      let totalDataSize = 0
-      for (const { data } of processedEntries) {
-        totalDataSize += data.length
-      }
+    // Calculate total data size (using compressed sizes where applicable)
+    let totalDataSize = 0
+    for (const { data } of processedEntries) {
+      totalDataSize += data.length
+    }
 
-      // Build index - iterate until offsets stabilize
-      // (offset changes -> JSON length changes -> header size changes -> offset changes)
-      // Header format: [index length: 4][CRC32: 4][JSON index][file data...]
-      const newIndex: PackIndex = {}
-      let headerSize = 8 // 4 bytes index length + 4 bytes CRC32
-      let prevHeaderSize = 0
-
-      // Iterate until stable (usually 2-3 iterations)
-      while (headerSize !== prevHeaderSize) {
-        prevHeaderSize = headerSize
-
-        let currentOffset = headerSize
-        for (const { path, data, originalSize } of processedEntries) {
-          const entry: PackIndexEntry = { offset: currentOffset, size: data.length }
-          if (originalSize !== undefined) {
-            entry.originalSize = originalSize
-          }
-          newIndex[path] = entry
-          currentOffset += data.length
+    // Build index - iterate until offsets stabilize
+    // (offset changes -> JSON length changes -> header size changes -> offset changes)
+    // Header format: [index length: 4][CRC32: 4][JSON index][file data...]
+    const newIndex: PackIndex = {}
+    let headerSize = 8 // 4 bytes index length + 4 bytes CRC32
+    let prevHeaderSize = 0
+
+    // Iterate until stable (usually 2-3 iterations)
+    while (headerSize !== prevHeaderSize) {
+      prevHeaderSize = headerSize
+
+      let currentOffset = headerSize
+      for (const { path, data, originalSize } of processedEntries) {
+        const entry: PackIndexEntry = { offset: currentOffset, size: data.length }
+        if (originalSize !== undefined) {
+          entry.originalSize = originalSize
         }
-
-        const indexBuf = encoder.encode(JSON.stringify(newIndex))
-        headerSize = 8 + indexBuf.length
+        newIndex[path] = entry
+        currentOffset += data.length
       }
 
-      // Build the complete pack file
-      const finalIndexBuf = encoder.encode(JSON.stringify(newIndex))
-      const totalSize = headerSize + totalDataSize
-      const packBuffer = new Uint8Array(totalSize)
-      const view = new DataView(packBuffer.buffer)
+      const indexBuf = encoder.encode(JSON.stringify(newIndex))
+      headerSize = 8 + indexBuf.length
+    }
 
-      // Write index JSON at offset 8
-      packBuffer.set(finalIndexBuf, 8)
+    // Build the complete pack file
+    const finalIndexBuf = encoder.encode(JSON.stringify(newIndex))
+    const totalSize = headerSize + totalDataSize
+    const packBuffer = new Uint8Array(totalSize)
+    const view = new DataView(packBuffer.buffer)
 
-      // Write data at correct offsets
-      for (const { path, data } of processedEntries) {
-        const entry = newIndex[path]
-        packBuffer.set(data, entry.offset)
-      }
+    // Write index JSON at offset 8
+    packBuffer.set(finalIndexBuf, 8)
 
-      // Calculate CRC32 over content (index + data, everything after header) if enabled
-      const content = packBuffer.subarray(8)
-      const checksum = this.useChecksum ? crc32(content) : 0
+    // Write data at correct offsets
+    for (const { path, data } of processedEntries) {
+      const entry = newIndex[path]
+      packBuffer.set(data, entry.offset)
+    }
 
-      // Write header (index length + CRC32)
-      view.setUint32(0, finalIndexBuf.length, true)
-      view.setUint32(4, checksum, true)
+    // Calculate CRC32 over content (index + data, everything after header) if enabled
+    const content = packBuffer.subarray(8)
+    const checksum = this.useChecksum ? crc32(content) : 0
 
-      await this.writePackFile(packBuffer)
-      this.index = newIndex
-    } finally {
-      release()
-    }
+    // Write header (index length + CRC32)
+    view.setUint32(0, finalIndexBuf.length, true)
+    view.setUint32(4, checksum, true)
+
+    await this.writePackFile(packBuffer)
+    this.index = newIndex
   }
 
   /**
@@ -502,12 +475,17 @@ export class PackedStorage {
     if (!fileHandle) return
 
     if (this.useSync) {
-      const access = await fileHandle.createSyncAccessHandle()
+      const releaseLock = await fileLockManager.acquire(PACK_FILE)
       try {
-        access.truncate(data.length)
-        access.write(data, { at: 0 })
+        const access = await fileHandle.createSyncAccessHandle()
+        try {
+          access.truncate(data.length)
+          access.write(data, { at: 0 })
+        } finally {
+          access.close()
+        }
       } finally {
-        access.close()
+        releaseLock()
       }
     } else {
       const writable = await fileHandle.createWritable()
@@ -521,21 +499,21 @@ export class PackedStorage {
    * Note: Doesn't reclaim space, just removes from index and recalculates CRC32
    */
   async remove(path: string): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      if (!(path in index)) return false
+    const index = await this.loadIndex()
+    if (!(path in index)) return false
 
-      delete index[path]
+    delete index[path]
 
-      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
-      if (!fileHandle) return true
+    const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+    if (!fileHandle) return true
 
-      // Need to read existing file to recalculate CRC32
-      const encoder = new TextEncoder()
-      const newIndexBuf = encoder.encode(JSON.stringify(index))
+    // Need to read existing file to recalculate CRC32
+    const encoder = new TextEncoder()
+    const newIndexBuf = encoder.encode(JSON.stringify(index))
 
-      if (this.useSync) {
+    if (this.useSync) {
+      const releaseLock = await fileLockManager.acquire(PACK_FILE)
+      try {
         const access = await fileHandle.createSyncAccessHandle()
         try {
           const size = access.getSize()
@@ -579,53 +557,48 @@ export class PackedStorage {
         } finally {
           access.close()
         }
-      } else {
-        // For non-sync, rewrite the whole file
-        const file = await fileHandle.getFile()
-        const oldData = new Uint8Array(await file.arrayBuffer())
-
-        if (oldData.length < 8) return true
+      } finally {
+        releaseLock()
+      }
+    } else {
+      // For non-sync, rewrite the whole file
+      const file = await fileHandle.getFile()
+      const oldData = new Uint8Array(await file.arrayBuffer())
 
-        const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
-        const dataStart = 8 + oldIndexLen
-        const dataPortion = oldData.subarray(dataStart)
+      if (oldData.length < 8) return true
 
-        // Build new content
-        const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
-        newContent.set(newIndexBuf, 0)
-        newContent.set(dataPortion, newIndexBuf.length)
+      const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
+      const dataStart = 8 + oldIndexLen
+      const dataPortion = oldData.subarray(dataStart)
 
-        // Calculate CRC32 if enabled
-        const checksum = this.useChecksum ? crc32(newContent) : 0
+      // Build new content
+      const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
+      newContent.set(newIndexBuf, 0)
+      newContent.set(dataPortion, newIndexBuf.length)
 
-        // Build new file
-        const newFile = new Uint8Array(8 + newContent.length)
-        const view = new DataView(newFile.buffer)
-        view.setUint32(0, newIndexBuf.length, true)
-        view.setUint32(4, checksum, true)
-        newFile.set(newContent, 8)
+      // Calculate CRC32 if enabled
+      const checksum = this.useChecksum ? crc32(newContent) : 0
 
-        const writable = await fileHandle.createWritable()
-        await writable.write(newFile)
-        await writable.close()
-      }
+      // Build new file
+      const newFile = new Uint8Array(8 + newContent.length)
+      const view = new DataView(newFile.buffer)
+      view.setUint32(0, newIndexBuf.length, true)
+      view.setUint32(4, checksum, true)
+      newFile.set(newContent, 8)
 
-      return true
-    } finally {
-      release()
+      const writable = await fileHandle.createWritable()
+      await writable.write(newFile)
+      await writable.close()
     }
+
+    return true
   }
 
   /**
    * Check if pack file is being used (has entries)
    */
   async isEmpty(): Promise<boolean> {
-    const release = await this.acquireLock()
-    try {
-      const index = await this.loadIndex()
-      return Object.keys(index).length === 0
-    } finally {
-      release()
-    }
+    const index = await this.loadIndex()
+    return Object.keys(index).length === 0
   }
 }

package/src/symlink-manager.ts

@@ -1,5 +1,6 @@
 import type { SymlinkCache, SymlinkDefinition } from './types.js'
 import type { HandleManager } from './handle-manager.js'
+import { fileLockManager } from './handle-manager.js'
 import { normalize } from './path-utils.js'
 import { createELOOP, createEINVAL, createEEXIST } from './errors.js'
 
@@ -101,13 +102,21 @@ export class SymlinkManager {
     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)