@componentor/fs 3.0.50 → 3.0.52

package/dist/index.js

@@ -362,7 +362,12 @@ var OP = {
 var SAB_OFFSETS = {
   // Int32 - bytes in this chunk
   TOTAL_LEN: 16,
-  // Int32 - reserved
+  // Int32 - 0-based chunk index
+  HEARTBEAT: 28,
+  // Int32 - liveness counter; the relay worker bumps this ~1×/s
+  //         while its event loop is alive (incl. mid-await of a
+  //         long op) so a spin-waiting main thread can tell
+  //         "slow" from "dead". Never written by the main thread.
   HEADER_SIZE: 32
   // Data payload starts here
 };
@@ -2556,19 +2561,37 @@ var DEFAULT_SAB_SIZE = 2 * 1024 * 1024;
 var instanceRegistry = /* @__PURE__ */ new Map();
 var HEADER_SIZE = SAB_OFFSETS.HEADER_SIZE;
 var _canAtomicsWait = typeof globalThis.WorkerGlobalScope !== "undefined";
-var SPIN_TIMEOUT_MS = 1e4;
-function spinWait(arr, index, value) {
+var SAB_HEARTBEAT_INDEX = SAB_OFFSETS.HEARTBEAT >> 2;
+var SPIN_STALL_TIMEOUT_MS = 2e4;
+var SPIN_NO_HEARTBEAT_TIMEOUT_MS = 3e4;
+function spinWait(arr, index, value, heartbeatArr) {
   if (_canAtomicsWait) {
     Atomics.wait(arr, index, value);
-  } else {
+    return;
+  }
+  if (!heartbeatArr) {
     const start = performance.now();
     while (Atomics.load(arr, index) === value) {
-      if (performance.now() - start > SPIN_TIMEOUT_MS) {
+      if (performance.now() - start > SPIN_NO_HEARTBEAT_TIMEOUT_MS) {
         throw new Error(
-          `VFS sync operation timed out after ${SPIN_TIMEOUT_MS / 1e3}s \u2014 SharedWorker may be unresponsive`
+          `VFS sync operation timed out after ${SPIN_NO_HEARTBEAT_TIMEOUT_MS / 1e3}s \u2014 relay worker did not respond`
         );
       }
     }
+    return;
+  }
+  let lastBeat = Atomics.load(heartbeatArr, SAB_HEARTBEAT_INDEX);
+  let lastProgress = performance.now();
+  while (Atomics.load(arr, index) === value) {
+    const beat = Atomics.load(heartbeatArr, SAB_HEARTBEAT_INDEX);
+    if (beat !== lastBeat) {
+      lastBeat = beat;
+      lastProgress = performance.now();
+    } else if (performance.now() - lastProgress > SPIN_STALL_TIMEOUT_MS) {
+      throw new Error(
+        `VFS sync operation aborted: relay worker heartbeat stalled for ${SPIN_STALL_TIMEOUT_MS / 1e3}s \u2014 worker is unresponsive`
+      );
+    }
   }
 }
 var VFSFileSystem = class {
@@ -3041,7 +3064,7 @@ var VFSFileSystem = class {
     if (signal === -1) {
       throw this.initError ?? new Error("VFS initialization failed");
     }
-    spinWait(this.readySignal, 0, 0);
+    spinWait(this.readySignal, 0, 0, this.ctrl);
     const finalSignal = Atomics.load(this.readySignal, 0);
     if (finalSignal === -1) {
       throw this.initError ?? new Error("VFS initialization failed");
@@ -3055,7 +3078,8 @@ var VFSFileSystem = class {
     const maxChunk = this.sab.byteLength - HEADER_SIZE;
     const requestBytes = new Uint8Array(requestBuf);
     const totalLenView = new BigUint64Array(this.sab, SAB_OFFSETS.TOTAL_LEN, 1);
-    if (requestBytes.byteLength <= maxChunk) {
+    const multiChunkRequest = requestBytes.byteLength > maxChunk;
+    if (!multiChunkRequest) {
       new Uint8Array(this.sab, HEADER_SIZE, requestBytes.byteLength).set(requestBytes);
       Atomics.store(this.ctrl, 3, requestBytes.byteLength);
       Atomics.store(totalLenView, 0, BigInt(requestBytes.byteLength));
@@ -3079,11 +3103,11 @@ var VFSFileSystem = class {
         Atomics.notify(this.ctrl, 0);
         sent += chunkSize;
         if (sent < requestBytes.byteLength) {
-          spinWait(this.ctrl, 0, sent === chunkSize ? SIGNAL.REQUEST : SIGNAL.CHUNK);
+          spinWait(this.ctrl, 0, sent === chunkSize ? SIGNAL.REQUEST : SIGNAL.CHUNK, this.ctrl);
         }
       }
     }
-    spinWait(this.ctrl, 0, SIGNAL.REQUEST);
+    spinWait(this.ctrl, 0, multiChunkRequest ? SIGNAL.CHUNK : SIGNAL.REQUEST, this.ctrl);
     const signal = Atomics.load(this.ctrl, 0);
     const respChunkLen = Atomics.load(this.ctrl, 3);
     const respTotalLen = Number(Atomics.load(totalLenView, 0));
@@ -3099,7 +3123,7 @@ var VFSFileSystem = class {
       while (received < respTotalLen) {
         Atomics.store(this.ctrl, 0, SIGNAL.CHUNK_ACK);
         Atomics.notify(this.ctrl, 0);
-        spinWait(this.ctrl, 0, SIGNAL.CHUNK_ACK);
+        spinWait(this.ctrl, 0, SIGNAL.CHUNK_ACK, this.ctrl);
         const nextLen = Atomics.load(this.ctrl, 3);
         responseBytes.set(new Uint8Array(this.sab, HEADER_SIZE, nextLen), received);
         received += nextLen;
@@ -4257,6 +4281,22 @@ var VFSEngine = class {
   // generation when implicitDirs was last rebuilt
   pathIndexGen = 0;
   // bumped on every pathIndex mutation
+  // Incrementally maintained "number of pathIndex entries that have this
+  // path as a strict ancestor" map. Lets `isImplicitDirectory` answer in
+  // O(1) — an implicit dir P is exactly !pathIndex.has(P) && descCount[P] > 0.
+  // Without this, every `isImplicitDirectory` call triggered an O(N×depth)
+  // rebuild of `implicitDirs`, and the 3.0.49 fix put one of those calls on
+  // the hot path of every fresh write/symlink/link/copy — making batch
+  // writes O(N²) on total path count.
+  descCount = /* @__PURE__ */ new Map();
+  // descCount is in sync with pathIndex iff descCountGen >= pathIndexGen.
+  // Helpers `setPathIndex`/`deletePathIndex` keep them in sync. Code that
+  // mutates `pathIndex` directly (only test scaffolding does this in
+  // practice — see the implicit-directory tests in vfs-engine.test.ts)
+  // bumps `pathIndexGen` without going through the helpers, which leaves
+  // descCount stale; `isImplicitDirectory` notices the mismatch and
+  // recomputes descCount on demand.
+  descCountGen = 0;
   // Configurable upper bounds
   maxInodes = 4e6;
   maxBlocks = 4e6;
@@ -4539,7 +4579,7 @@ var VFSEngine = class {
       if (!path.startsWith("/") || path.includes("\0")) {
         throw new Error(`Corrupt VFS: inode ${i} has invalid path "${path.substring(0, 50)}"`);
       }
-      this.pathIndex.set(path, i);
+      this.setPathIndex(path, i);
     }
     this.pathIndexGen++;
   }
@@ -4861,7 +4901,7 @@ var VFSEngine = class {
       gid: this.processGid
     };
     this.writeInode(idx, inode);
-    this.pathIndex.set(path, idx);
+    this.setPathIndex(path, idx);
     this.pathIndexGen++;
     return idx;
   }
@@ -5019,7 +5059,7 @@ var VFSEngine = class {
     this.freeBlockRange(inode.firstBlock, inode.blockCount);
     inode.type = INODE_TYPE.FREE;
     this.writeInode(idx, inode);
-    this.pathIndex.delete(path);
+    this.deletePathIndex(path);
     this.pathIndexGen++;
     if (idx < this.freeInodeHint) this.freeInodeHint = idx;
     this.commitPending();
@@ -5141,7 +5181,7 @@ var VFSEngine = class {
             this.freeBlockRange(descInode.firstBlock, descInode.blockCount);
             descInode.type = INODE_TYPE.FREE;
             this.writeInode(descIdx, descInode);
-            this.pathIndex.delete(desc);
+            this.deletePathIndex(desc);
           }
           this.pathIndexGen++;
           this.commitPending();
@@ -5161,12 +5201,12 @@ var VFSEngine = class {
         this.freeBlockRange(childInode.firstBlock, childInode.blockCount);
         childInode.type = INODE_TYPE.FREE;
         this.writeInode(childIdx, childInode);
-        this.pathIndex.delete(child);
+        this.deletePathIndex(child);
       }
     }
     inode.type = INODE_TYPE.FREE;
     this.writeInode(idx, inode);
-    this.pathIndex.delete(path);
+    this.deletePathIndex(path);
     this.pathIndexGen++;
     if (idx < this.freeInodeHint) this.freeInodeHint = idx;
     this.commitPending();
@@ -5257,7 +5297,7 @@ var VFSEngine = class {
         this.freeBlockRange(existingInode.firstBlock, existingInode.blockCount);
         existingInode.type = INODE_TYPE.FREE;
         this.writeInode(existingIdx, existingInode);
-        this.pathIndex.delete(newPath);
+        this.deletePathIndex(newPath);
         if (existingIdx < this.freeInodeHint) this.freeInodeHint = existingIdx;
       }
       if (cleanDescendants) {
@@ -5267,7 +5307,7 @@ var VFSEngine = class {
           this.freeBlockRange(descInode.firstBlock, descInode.blockCount);
           descInode.type = INODE_TYPE.FREE;
           this.writeInode(descIdx, descInode);
-          this.pathIndex.delete(desc);
+          this.deletePathIndex(desc);
           if (descIdx < this.freeInodeHint) this.freeInodeHint = descIdx;
         }
       }
@@ -5278,8 +5318,8 @@ var VFSEngine = class {
     inode.pathLength = pathLen;
     inode.mtime = Date.now();
     this.writeInode(idx, inode);
-    this.pathIndex.delete(oldPath);
-    this.pathIndex.set(newPath, idx);
+    this.deletePathIndex(oldPath);
+    this.setPathIndex(newPath, idx);
     this.pathIndexGen++;
     if (inode.type === INODE_TYPE.DIRECTORY) {
       const prefix = oldPath === "/" ? "/" : oldPath + "/";
@@ -5297,8 +5337,8 @@ var VFSEngine = class {
         childInode.pathOffset = cpo;
         childInode.pathLength = cpl;
         this.writeInode(i, childInode);
-        this.pathIndex.delete(p);
-        this.pathIndex.set(childNewPath, i);
+        this.deletePathIndex(p);
+        this.setPathIndex(childNewPath, i);
       }
     }
     this.commitPending();
@@ -5767,11 +5807,71 @@ var VFSEngine = class {
   /**
    * Check if a path is an implicit directory (exists because files exist under it,
    * but no explicit directory inode was created for it).
+   *
+   * O(1) via the incrementally maintained `descCount` map (an implicit dir
+   * is exactly !pathIndex.has(P) && descCount[P] > 0). If `pathIndex` was
+   * mutated directly without going through the helpers (test scaffolding),
+   * descCount is stale and we rebuild it from scratch — once — to resync.
    */
   isImplicitDirectory(path) {
     if (path === "/") return false;
-    this.rebuildImplicitDirs();
-    return this.implicitDirs.has(path);
+    if (this.pathIndex.has(path)) return false;
+    if (this.descCountGen < this.pathIndexGen) this.rebuildDescCount();
+    return (this.descCount.get(path) ?? 0) > 0;
+  }
+  /**
+   * Recompute `descCount` from scratch by walking every pathIndex entry's
+   * ancestor chain. O(N×depth). Only triggered when something bypassed the
+   * setPathIndex/deletePathIndex helpers — in production code that's
+   * never; the tests exercise this path.
+   */
+  rebuildDescCount() {
+    this.descCount.clear();
+    for (const path of this.pathIndex.keys()) {
+      this.bumpDescCount(path);
+    }
+    this.descCountGen = this.pathIndexGen;
+  }
+  // ---- pathIndex helpers — keep `descCount` in sync ----
+  // Every pathIndex.set/delete in the engine MUST go through these so the
+  // `descCount` map (used by `isImplicitDirectory`) stays correct. We
+  // anticipate the caller's `pathIndexGen++` by setting `descCountGen` to
+  // `pathIndexGen + 1`; idempotent across multiple helper calls within a
+  // single logical op (e.g. rmdir doing N deletes then one bump). Test
+  // code that mutates `pathIndex` directly leaves descCountGen behind,
+  // which is what triggers the rebuild path in `isImplicitDirectory`.
+  setPathIndex(path, idx) {
+    const had = this.pathIndex.has(path);
+    this.pathIndex.set(path, idx);
+    if (!had) this.bumpDescCount(path);
+    this.descCountGen = this.pathIndexGen + 1;
+  }
+  deletePathIndex(path) {
+    const had = this.pathIndex.delete(path);
+    if (had) this.decDescCount(path);
+    this.descCountGen = this.pathIndexGen + 1;
+    return had;
+  }
+  bumpDescCount(path) {
+    let pos = path.length;
+    while (true) {
+      pos = path.lastIndexOf("/", pos - 1);
+      if (pos <= 0) break;
+      const ancestor = path.substring(0, pos);
+      this.descCount.set(ancestor, (this.descCount.get(ancestor) ?? 0) + 1);
+    }
+  }
+  decDescCount(path) {
+    let pos = path.length;
+    while (true) {
+      pos = path.lastIndexOf("/", pos - 1);
+      if (pos <= 0) break;
+      const ancestor = path.substring(0, pos);
+      const cur = this.descCount.get(ancestor);
+      if (cur === void 0) break;
+      if (cur <= 1) this.descCount.delete(ancestor);
+      else this.descCount.set(ancestor, cur - 1);
+    }
   }
   /**
    * Get direct children of a directory path, including implicit subdirectories.