@componentor/fs 2.0.8 → 2.0.10

package/dist/index.js

@@ -441,22 +441,30 @@ function trace(...args) {
   if (debugTrace) console.log('[OPFS-T2]', ...args);
 }
 
-// Minimal timer for legacy mode only
+// Handle release timing
+// - Legacy mode (readwrite): 100ms delay (handles block, release ASAP)
+// - Unsafe mode (readwrite-unsafe): 500ms delay (handles don't block each other,
+//   but DO block external tools using default mode like OPFS Explorer)
 let releaseTimer = null;
 const LEGACY_RELEASE_DELAY = 100;
+const UNSAFE_RELEASE_DELAY = 500;
 
 function scheduleHandleRelease() {
-  if (unsafeModeSupported) return; // No release needed for readwrite-unsafe
   if (releaseTimer) return; // Already scheduled
+
+  const delay = unsafeModeSupported ? UNSAFE_RELEASE_DELAY : LEGACY_RELEASE_DELAY;
+
   releaseTimer = setTimeout(() => {
     releaseTimer = null;
     const count = syncHandleCache.size;
+    if (count === 0) return;
+
     for (const h of syncHandleCache.values()) {
       try { h.flush(); h.close(); } catch {}
     }
     syncHandleCache.clear();
-    trace('Released ' + count + ' handles (legacy mode debounce)');
-  }, LEGACY_RELEASE_DELAY);
+    trace('Released ' + count + ' handles (' + (unsafeModeSupported ? 'unsafe' : 'legacy') + ' mode, ' + delay + 'ms delay)');
+  }, delay);
 }
 
 async function getSyncHandle(filePath, create) {
@@ -942,18 +950,19 @@ async function handleMessage(msg) {
 function processQueue() {
   while (messageQueue.length > 0) {
     const msg = messageQueue.shift();
-    handleMessage(msg);
+    handleMessage(msg); // Process concurrently - don't wait
   }
 }
 
-// Handle messages directly - no serialization needed because:
-// - Tier 2: Client awaits response before sending next message
-// - Each OPFSFileSystem instance has its own worker
+// Handle messages concurrently - each operation proceeds independently
+// This is better than a queue with concurrency limit because:
+// 1. If one operation hangs, others can still complete
+// 2. Small files don't get blocked behind large files
+// 3. The Web Locks API already handles per-file serialization
 self.onmessage = (event) => {
+  messageQueue.push(event.data);
   if (isReady) {
-    handleMessage(event.data);
-  } else {
-    messageQueue.push(event.data);
+    processQueue();
   }
 };