@componentor/fs 1.2.2 → 1.2.4

package/src/packed-storage.ts

@@ -128,6 +128,7 @@ 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
@@ -137,6 +138,23 @@ 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)
    */
@@ -163,9 +181,9 @@ export class PackedStorage {
   /**
    * Load pack index from disk (always reloads to support hybrid mode)
    * Verifies CRC32 checksum for integrity
+   * Note: Caller must hold the lock
    */
   private async loadIndex(): Promise<PackIndex> {
-    // Always reload from disk to ensure we see writes from other threads/workers
     try {
       const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
       if (!fileHandle) {
@@ -174,36 +192,38 @@ export class PackedStorage {
 
       if (this.useSync) {
         const access = await fileHandle.createSyncAccessHandle()
-        const size = access.getSize()
-        if (size < 8) {
-          access.close()
-          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 })
-        access.close()
+        try {
+          const size = access.getSize()
+          if (size < 8) {
+            return {}
+          }
 
-        // 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()
+        }
       } else {
         const file = await fileHandle.getFile()
         const data = new Uint8Array(await file.arrayBuffer())
@@ -236,8 +256,13 @@ export class PackedStorage {
    * Check if a path exists in the pack
    */
   async has(path: string): Promise<boolean> {
-    const index = await this.loadIndex()
-    return path in index
+    const release = await this.acquireLock()
+    try {
+      const index = await this.loadIndex()
+      return path in index
+    } finally {
+      release()
+    }
   }
 
   /**
@@ -245,10 +270,15 @@ export class PackedStorage {
    * Returns originalSize if compressed, otherwise size
    */
   async getSize(path: string): Promise<number | null> {
-    const index = await this.loadIndex()
-    const entry = index[path]
-    if (!entry) return null
-    return entry.originalSize ?? entry.size
+    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()
+    }
   }
 
   /**
@@ -256,32 +286,40 @@ export class PackedStorage {
    * Handles decompression if file was stored compressed
    */
   async read(path: string): Promise<Uint8Array | null> {
-    const index = await this.loadIndex()
-    const entry = index[path]
-    if (!entry) return null
+    const release = await this.acquireLock()
+    try {
+      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) {
-      const access = await fileHandle.createSyncAccessHandle()
-      buffer = new Uint8Array(entry.size)
-      access.read(buffer, { at: entry.offset })
-      access.close()
-    } else {
-      const file = await fileHandle.getFile()
-      const data = new Uint8Array(await file.arrayBuffer())
-      buffer = data.slice(entry.offset, entry.offset + entry.size)
-    }
+      if (this.useSync) {
+        const access = await fileHandle.createSyncAccessHandle()
+        try {
+          buffer = new Uint8Array(entry.size)
+          access.read(buffer, { at: entry.offset })
+        } 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)
-    }
+      // Decompress if needed
+      if (entry.originalSize !== undefined) {
+        return decompress(buffer)
+      }
 
-    return buffer
+      return buffer
+    } finally {
+      release()
+    }
   }
 
   /**
@@ -293,66 +331,74 @@ export class PackedStorage {
     const results = new Map<string, Uint8Array | null>()
     if (paths.length === 0) return results
 
-    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 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)
+        }
       }
-    }
 
-    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)
+      const { fileHandle } = await this.handleManager.getHandle(PACK_FILE)
+      if (!fileHandle) {
+        for (const { path } of toRead) {
+          results.set(path, null)
+        }
+        return results
       }
-      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) {
-      const access = await fileHandle.createSyncAccessHandle()
-      for (const { path, offset, size, originalSize } of toRead) {
-        const buffer = new Uint8Array(size)
-        access.read(buffer, { at: offset })
+      if (this.useSync) {
+        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 !== undefined) {
+              // Queue for decompression
+              decompressPromises.push({ path, promise: decompress(buffer) })
+            } else {
+              results.set(path, buffer)
+            }
+          }
+        } 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) {
-          // Queue for decompression
-          decompressPromises.push({ path, promise: decompress(buffer) })
-        } else {
-          results.set(path, buffer)
+          if (originalSize !== undefined) {
+            decompressPromises.push({ path, promise: decompress(buffer) })
+          } else {
+            results.set(path, buffer)
+          }
         }
       }
-      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)
-        }
+      // Wait for all decompressions
+      for (const { path, promise } of decompressPromises) {
+        results.set(path, await promise)
       }
-    }
 
-    // Wait for all decompressions
-    for (const { path, promise } of decompressPromises) {
-      results.set(path, await promise)
+      return results
+    } finally {
+      release()
     }
-
-    return results
   }
 
   /**
@@ -365,85 +411,91 @@ export class PackedStorage {
   async writeBatch(entries: Array<{ path: string; data: Uint8Array }>): Promise<void> {
     if (entries.length === 0) return
 
-    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 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
+      }
 
-    // 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
+      // 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
         }
-        newIndex[path] = entry
-        currentOffset += data.length
-      }
 
-      const indexBuf = encoder.encode(JSON.stringify(newIndex))
-      headerSize = 8 + indexBuf.length
-    }
+        const indexBuf = encoder.encode(JSON.stringify(newIndex))
+        headerSize = 8 + indexBuf.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)
+      // 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 index JSON at offset 8
-    packBuffer.set(finalIndexBuf, 8)
+      // Write index JSON at offset 8
+      packBuffer.set(finalIndexBuf, 8)
 
-    // Write data at correct offsets
-    for (const { path, data } of processedEntries) {
-      const entry = newIndex[path]
-      packBuffer.set(data, entry.offset)
-    }
+      // Write data at correct offsets
+      for (const { path, data } of processedEntries) {
+        const entry = newIndex[path]
+        packBuffer.set(data, entry.offset)
+      }
 
-    // Calculate CRC32 over content (index + data, everything after header) if enabled
-    const content = packBuffer.subarray(8)
-    const checksum = this.useChecksum ? crc32(content) : 0
+      // Calculate CRC32 over content (index + data, everything after header) if enabled
+      const content = packBuffer.subarray(8)
+      const checksum = this.useChecksum ? crc32(content) : 0
 
-    // Write header (index length + CRC32)
-    view.setUint32(0, finalIndexBuf.length, true)
-    view.setUint32(4, checksum, true)
+      // Write header (index length + CRC32)
+      view.setUint32(0, finalIndexBuf.length, true)
+      view.setUint32(4, checksum, true)
 
-    await this.writePackFile(packBuffer)
-    this.index = newIndex
+      await this.writePackFile(packBuffer)
+      this.index = newIndex
+    } finally {
+      release()
+    }
   }
 
   /**
    * Write the pack file to OPFS
+   * Note: Caller must hold the lock
    */
   private async writePackFile(data: Uint8Array): Promise<void> {
     const { fileHandle } = await this.handleManager.getHandle(PACK_FILE, { create: true })
@@ -451,9 +503,12 @@ export class PackedStorage {
 
     if (this.useSync) {
       const access = await fileHandle.createSyncAccessHandle()
-      access.truncate(data.length)
-      access.write(data, { at: 0 })
-      access.close()
+      try {
+        access.truncate(data.length)
+        access.write(data, { at: 0 })
+      } finally {
+        access.close()
+      }
     } else {
       const writable = await fileHandle.createWritable()
       await writable.write(data)
@@ -466,98 +521,111 @@ export class PackedStorage {
    * Note: Doesn't reclaim space, just removes from index and recalculates CRC32
    */
   async remove(path: string): Promise<boolean> {
-    const index = await this.loadIndex()
-    if (!(path in index)) return false
+    const release = await this.acquireLock()
+    try {
+      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) {
-      const access = await fileHandle.createSyncAccessHandle()
-      const size = access.getSize()
-
-      // Read old header to get old index length
-      const oldHeader = new Uint8Array(8)
-      access.read(oldHeader, { at: 0 })
-      const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true)
-
-      // Read data portion (after old index)
-      const dataStart = 8 + oldIndexLen
-      const dataSize = size - dataStart
-      const dataPortion = new Uint8Array(dataSize)
-      if (dataSize > 0) {
-        access.read(dataPortion, { at: dataStart })
-      }
+      if (this.useSync) {
+        const access = await fileHandle.createSyncAccessHandle()
+        try {
+          const size = access.getSize()
+
+          // Read old header to get old index length
+          const oldHeader = new Uint8Array(8)
+          access.read(oldHeader, { at: 0 })
+          const oldIndexLen = new DataView(oldHeader.buffer).getUint32(0, true)
+
+          // Read data portion (after old index)
+          const dataStart = 8 + oldIndexLen
+          const dataSize = size - dataStart
+          const dataPortion = new Uint8Array(dataSize)
+          if (dataSize > 0) {
+            access.read(dataPortion, { at: dataStart })
+          }
 
-      // Build new content (new index + data)
-      const newContent = new Uint8Array(newIndexBuf.length + dataSize)
-      newContent.set(newIndexBuf, 0)
-      if (dataSize > 0) {
-        newContent.set(dataPortion, newIndexBuf.length)
-      }
+          // Build new content (new index + data)
+          const newContent = new Uint8Array(newIndexBuf.length + dataSize)
+          newContent.set(newIndexBuf, 0)
+          if (dataSize > 0) {
+            newContent.set(dataPortion, newIndexBuf.length)
+          }
 
-      // Calculate new CRC32 if enabled
-      const checksum = this.useChecksum ? crc32(newContent) : 0
+          // Calculate new CRC32 if enabled
+          const checksum = this.useChecksum ? crc32(newContent) : 0
 
-      // Build new header
-      const newHeader = new Uint8Array(8)
-      const view = new DataView(newHeader.buffer)
-      view.setUint32(0, newIndexBuf.length, true)
-      view.setUint32(4, checksum, true)
+          // Build new header
+          const newHeader = new Uint8Array(8)
+          const view = new DataView(newHeader.buffer)
+          view.setUint32(0, newIndexBuf.length, true)
+          view.setUint32(4, checksum, true)
 
-      // Write new file
-      const newFile = new Uint8Array(8 + newContent.length)
-      newFile.set(newHeader, 0)
-      newFile.set(newContent, 8)
+          // Write new file
+          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 {
-      // For non-sync, rewrite the whole file
-      const file = await fileHandle.getFile()
-      const oldData = new Uint8Array(await file.arrayBuffer())
+          access.truncate(newFile.length)
+          access.write(newFile, { at: 0 })
+        } 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
+        if (oldData.length < 8) return true
 
-      const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
-      const dataStart = 8 + oldIndexLen
-      const dataPortion = oldData.subarray(dataStart)
+        const oldIndexLen = new DataView(oldData.buffer).getUint32(0, true)
+        const dataStart = 8 + oldIndexLen
+        const dataPortion = oldData.subarray(dataStart)
 
-      // Build new content
-      const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
-      newContent.set(newIndexBuf, 0)
-      newContent.set(dataPortion, newIndexBuf.length)
+        // Build new content
+        const newContent = new Uint8Array(newIndexBuf.length + dataPortion.length)
+        newContent.set(newIndexBuf, 0)
+        newContent.set(dataPortion, newIndexBuf.length)
 
-      // Calculate CRC32 if enabled
-      const checksum = this.useChecksum ? crc32(newContent) : 0
+        // Calculate CRC32 if enabled
+        const checksum = this.useChecksum ? crc32(newContent) : 0
 
-      // 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)
+        // 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)
 
-      const writable = await fileHandle.createWritable()
-      await writable.write(newFile)
-      await writable.close()
-    }
+        const writable = await fileHandle.createWritable()
+        await writable.write(newFile)
+        await writable.close()
+      }
 
-    return true
+      return true
+    } finally {
+      release()
+    }
   }
 
   /**
    * Check if pack file is being used (has entries)
    */
   async isEmpty(): Promise<boolean> {
-    const index = await this.loadIndex()
-    return Object.keys(index).length === 0
+    const release = await this.acquireLock()
+    try {
+      const index = await this.loadIndex()
+      return Object.keys(index).length === 0
+    } finally {
+      release()
+    }
   }
 }