@componentor/fs 3.0.44 → 3.0.46

package/dist/workers/sync-relay.worker.js

@@ -154,6 +154,16 @@ var VFSEngine = class {
   superblockDirty = false;
   // Free inode hint — skip O(n) scan
   freeInodeHint = 0;
+  // Implicit directory support — tracks all directory prefixes implied by file paths.
+  // Rebuilt lazily when pathIndex changes (tracked via generation counter).
+  // Map value is the stable timestamp (ms since epoch) assigned when the implicit
+  // dir was first discovered, so that stat() returns consistent mtime/ctime/atime
+  // across repeated calls.
+  implicitDirs = /* @__PURE__ */ new Map();
+  implicitDirsGen = -1;
+  // generation when implicitDirs was last rebuilt
+  pathIndexGen = 0;
+  // bumped on every pathIndex mutation
   // Configurable upper bounds
   maxInodes = 4e6;
   maxBlocks = 4e6;
@@ -438,6 +448,7 @@ var VFSEngine = class {
       }
       this.pathIndex.set(path, i);
     }
+    this.pathIndexGen++;
   }
   // ========== Low-level inode I/O ==========
   readInode(idx) {
@@ -510,14 +521,23 @@ var VFSEngine = class {
   growPathTable(needed) {
     const newSize = Math.max(this.pathTableSize * 2, needed + INITIAL_PATH_TABLE_SIZE);
     const growth = newSize - this.pathTableSize;
-    const dataSize = this.totalBlocks * this.blockSize;
-    const dataBuf = new Uint8Array(dataSize);
-    this.handle.read(dataBuf, { at: this.dataOffset });
     const newTotalSize = this.handle.getSize() + growth;
     this.handle.truncate(newTotalSize);
+    const dataSize = this.totalBlocks * this.blockSize;
+    const CHUNK = 4 * 1024 * 1024;
+    const scratch = new Uint8Array(Math.min(CHUNK, Math.max(dataSize, 1)));
+    let remaining = dataSize;
+    while (remaining > 0) {
+      const chunk = Math.min(remaining, CHUNK);
+      const srcAt = this.dataOffset + (remaining - chunk);
+      const dstAt = this.dataOffset + growth + (remaining - chunk);
+      const slice = chunk < scratch.length ? scratch.subarray(0, chunk) : scratch;
+      this.handle.read(slice, { at: srcAt });
+      this.handle.write(slice, { at: dstAt });
+      remaining -= chunk;
+    }
     const newBitmapOffset = this.bitmapOffset + growth;
     const newDataOffset = this.dataOffset + growth;
-    this.handle.write(dataBuf, { at: newDataOffset });
     this.handle.write(this.bitmap, { at: newBitmapOffset });
     this.pathTableSize = newSize;
     this.bitmapOffset = newBitmapOffset;
@@ -525,6 +545,23 @@ var VFSEngine = class {
     this.superblockDirty = true;
   }
   // ========== Bitmap I/O ==========
+  // Write `length` zero bytes at absolute file offset `at` via a small
+  // reusable scratch buffer. Used to materialize POSIX "holes" when a
+  // write starts past the current file size — those bytes must read as
+  // zeros rather than whatever stale data happened to live in the
+  // underlying storage blocks.
+  zeroFileRange(at, length) {
+    if (length <= 0) return;
+    const CHUNK = 4 * 1024 * 1024;
+    const zeros = new Uint8Array(Math.min(length, CHUNK));
+    let written = 0;
+    while (written < length) {
+      const n = Math.min(CHUNK, length - written);
+      const slice = n < zeros.length ? zeros.subarray(0, n) : zeros;
+      this.handle.write(slice, { at: at + written });
+      written += n;
+    }
+  }
   allocateBlocks(count) {
     if (count === 0) return 0;
     const bitmap = this.bitmap;
@@ -732,6 +769,7 @@ var VFSEngine = class {
     };
     this.writeInode(idx, inode);
     this.pathIndex.set(path, idx);
+    this.pathIndexGen++;
     return idx;
   }
   // ========== Public API — called by server worker dispatch ==========
@@ -849,17 +887,28 @@ var VFSEngine = class {
     }
     const inode = this.readInode(existingIdx);
     if (inode.type === INODE_TYPE.DIRECTORY) return { status: CODE_TO_STATUS.EISDIR };
-    const existing = inode.size > 0 ? this.readData(inode.firstBlock, inode.blockCount, inode.size) : new Uint8Array(0);
-    const combined = new Uint8Array(existing.byteLength + data.byteLength);
-    combined.set(existing);
-    combined.set(data, existing.byteLength);
-    const neededBlocks = Math.ceil(combined.byteLength / this.blockSize);
-    this.freeBlockRange(inode.firstBlock, inode.blockCount);
+    const combinedSize = inode.size + data.byteLength;
+    const neededBlocks = Math.ceil(combinedSize / this.blockSize);
     const newFirst = this.allocateBlocks(neededBlocks);
-    this.writeData(newFirst, combined);
+    const newBase = this.dataOffset + newFirst * this.blockSize;
+    if (inode.size > 0) {
+      const oldBase = this.dataOffset + inode.firstBlock * this.blockSize;
+      const CHUNK = 4 * 1024 * 1024;
+      const scratch = new Uint8Array(Math.min(CHUNK, inode.size));
+      let copied = 0;
+      while (copied < inode.size) {
+        const n = Math.min(CHUNK, inode.size - copied);
+        const slice = n < scratch.length ? scratch.subarray(0, n) : scratch;
+        this.handle.read(slice, { at: oldBase + copied });
+        this.handle.write(slice, { at: newBase + copied });
+        copied += n;
+      }
+    }
+    this.freeBlockRange(inode.firstBlock, inode.blockCount);
+    this.handle.write(data, { at: newBase + inode.size });
     inode.firstBlock = newFirst;
     inode.blockCount = neededBlocks;
-    inode.size = combined.byteLength;
+    inode.size = combinedSize;
     inode.mtime = Date.now();
     this.writeInode(existingIdx, inode);
     this.commitPending();
@@ -877,6 +926,7 @@ var VFSEngine = class {
     inode.type = INODE_TYPE.FREE;
     this.writeInode(idx, inode);
     this.pathIndex.delete(path);
+    this.pathIndexGen++;
     if (idx < this.freeInodeHint) this.freeInodeHint = idx;
     this.commitPending();
     return { status: 0 };
@@ -885,7 +935,12 @@ var VFSEngine = class {
   stat(path) {
     path = this.normalizePath(path);
     const idx = this.resolvePathComponents(path, true);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
+    if (idx === void 0) {
+      if (this.isImplicitDirectory(path)) {
+        return this.encodeImplicitDirStatResponse(path);
+      }
+      return { status: CODE_TO_STATUS.ENOENT, data: null };
+    }
     return this.encodeStatResponse(idx);
   }
   // ---- LSTAT (no symlink follow for the FINAL component) ----
@@ -894,7 +949,12 @@ var VFSEngine = class {
     let idx = this.resolvePathComponents(path, false);
     if (idx === void 0) {
       idx = this.resolvePathComponents(path, true);
-      if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
+      if (idx === void 0) {
+        if (this.isImplicitDirectory(path)) {
+          return this.encodeImplicitDirStatResponse(path);
+        }
+        return { status: CODE_TO_STATUS.ENOENT, data: null };
+      }
     }
     return this.encodeStatResponse(idx);
   }
@@ -903,13 +963,17 @@ var VFSEngine = class {
     let nlink = inode.nlink;
     if (inode.type === INODE_TYPE.DIRECTORY) {
       const path = this.readPath(inode.pathOffset, inode.pathLength);
-      const children = this.getDirectChildren(path);
+      const children = this.getDirectChildrenWithImplicit(path);
       let subdirCount = 0;
       for (const child of children) {
-        const childIdx = this.pathIndex.get(child);
-        if (childIdx !== void 0) {
-          const childInode = this.readInode(childIdx);
-          if (childInode.type === INODE_TYPE.DIRECTORY) subdirCount++;
+        if (child.type === "implicit") {
+          subdirCount++;
+        } else {
+          const childIdx = this.pathIndex.get(child.path);
+          if (childIdx !== void 0) {
+            const childInode = this.readInode(childIdx);
+            if (childInode.type === INODE_TYPE.DIRECTORY) subdirCount++;
+          }
         }
       }
       nlink = 2 + subdirCount;
@@ -935,7 +999,9 @@ var VFSEngine = class {
     if (recursive) {
       return this.mkdirRecursive(path);
     }
-    if (this.pathIndex.has(path)) return { status: CODE_TO_STATUS.EEXIST, data: null };
+    if (this.pathIndex.has(path) || this.isImplicitDirectory(path)) {
+      return { status: CODE_TO_STATUS.EEXIST, data: null };
+    }
     const parentStatus = this.ensureParent(path);
     if (parentStatus !== 0) return { status: parentStatus, data: null };
     const mode = DEFAULT_DIR_MODE & ~(this.umask & 511);
@@ -970,7 +1036,26 @@ var VFSEngine = class {
     path = this.normalizePath(path);
     const recursive = (flags & 1) !== 0;
     const idx = this.pathIndex.get(path);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT };
+    if (idx === void 0) {
+      if (this.isImplicitDirectory(path)) {
+        const children2 = this.getDirectChildrenWithImplicit(path);
+        if (children2.length > 0) {
+          if (!recursive) return { status: CODE_TO_STATUS.ENOTEMPTY };
+          for (const desc of this.getAllDescendants(path)) {
+            const descIdx = this.pathIndex.get(desc);
+            const descInode = this.readInode(descIdx);
+            this.freeBlockRange(descInode.firstBlock, descInode.blockCount);
+            descInode.type = INODE_TYPE.FREE;
+            this.writeInode(descIdx, descInode);
+            this.pathIndex.delete(desc);
+          }
+          this.pathIndexGen++;
+          this.commitPending();
+        }
+        return { status: 0 };
+      }
+      return { status: CODE_TO_STATUS.ENOENT };
+    }
     const inode = this.readInode(idx);
     if (inode.type !== INODE_TYPE.DIRECTORY) return { status: CODE_TO_STATUS.ENOTDIR };
     const children = this.getDirectChildren(path);
@@ -988,6 +1073,7 @@ var VFSEngine = class {
     inode.type = INODE_TYPE.FREE;
     this.writeInode(idx, inode);
     this.pathIndex.delete(path);
+    this.pathIndexGen++;
     if (idx < this.freeInodeHint) this.freeInodeHint = idx;
     this.commitPending();
     return { status: 0 };
@@ -996,20 +1082,33 @@ var VFSEngine = class {
   readdir(path, flags = 0) {
     path = this.normalizePath(path);
     const resolved = this.resolvePathFull(path, true);
-    if (!resolved) return { status: CODE_TO_STATUS.ENOENT, data: null };
-    const inode = this.readInode(resolved.idx);
-    if (inode.type !== INODE_TYPE.DIRECTORY) return { status: CODE_TO_STATUS.ENOTDIR, data: null };
+    let effectiveDirPath;
+    if (resolved) {
+      const inode = this.readInode(resolved.idx);
+      if (inode.type !== INODE_TYPE.DIRECTORY) return { status: CODE_TO_STATUS.ENOTDIR, data: null };
+      effectiveDirPath = resolved.resolvedPath;
+    } else if (this.isImplicitDirectory(path)) {
+      effectiveDirPath = path;
+    } else {
+      return { status: CODE_TO_STATUS.ENOENT, data: null };
+    }
     const withFileTypes = (flags & 1) !== 0;
-    const children = this.getDirectChildren(resolved.resolvedPath);
+    const children = this.getDirectChildrenWithImplicit(effectiveDirPath);
     if (withFileTypes) {
       let totalSize2 = 4;
       const entries = [];
-      for (const childPath of children) {
-        const name = childPath.substring(childPath.lastIndexOf("/") + 1);
+      for (const child of children) {
+        const name = child.path.substring(child.path.lastIndexOf("/") + 1);
         const nameBytes = encoder.encode(name);
-        const childIdx = this.pathIndex.get(childPath);
-        const childInode = this.readInode(childIdx);
-        entries.push({ name: nameBytes, type: childInode.type });
+        let type;
+        if (child.type === "implicit") {
+          type = INODE_TYPE.DIRECTORY;
+        } else {
+          const childIdx = this.pathIndex.get(child.path);
+          const childInode = this.readInode(childIdx);
+          type = childInode.type;
+        }
+        entries.push({ name: nameBytes, type });
         totalSize2 += 2 + nameBytes.byteLength + 1;
       }
       const buf2 = new Uint8Array(totalSize2);
@@ -1027,8 +1126,8 @@ var VFSEngine = class {
     }
     let totalSize = 4;
     const nameEntries = [];
-    for (const childPath of children) {
-      const name = childPath.substring(childPath.lastIndexOf("/") + 1);
+    for (const child of children) {
+      const name = child.path.substring(child.path.lastIndexOf("/") + 1);
       const nameBytes = encoder.encode(name);
       nameEntries.push(nameBytes);
       totalSize += 2 + nameBytes.byteLength;
@@ -1069,6 +1168,7 @@ var VFSEngine = class {
     this.writeInode(idx, inode);
     this.pathIndex.delete(oldPath);
     this.pathIndex.set(newPath, idx);
+    this.pathIndexGen++;
     if (inode.type === INODE_TYPE.DIRECTORY) {
       const prefix = oldPath === "/" ? "/" : oldPath + "/";
       const toRename = [];
@@ -1097,7 +1197,7 @@ var VFSEngine = class {
     path = this.normalizePath(path);
     const idx = this.resolvePathComponents(path, true);
     const buf = new Uint8Array(1);
-    buf[0] = idx !== void 0 ? 1 : 0;
+    buf[0] = idx !== void 0 || this.isImplicitDirectory(path) ? 1 : 0;
     return { status: 0, data: buf };
   }
   // ---- TRUNCATE ----
@@ -1122,13 +1222,29 @@ var VFSEngine = class {
     } else if (len > inode.size) {
       const neededBlocks = Math.ceil(len / this.blockSize);
       if (neededBlocks > inode.blockCount) {
-        const oldData = this.readData(inode.firstBlock, inode.blockCount, inode.size);
-        this.freeBlockRange(inode.firstBlock, inode.blockCount);
         const newFirst = this.allocateBlocks(neededBlocks);
-        const newData = new Uint8Array(len);
-        newData.set(oldData);
-        this.writeData(newFirst, newData);
+        const newBase = this.dataOffset + newFirst * this.blockSize;
+        if (inode.size > 0) {
+          const oldBase = this.dataOffset + inode.firstBlock * this.blockSize;
+          const CHUNK = 4 * 1024 * 1024;
+          const scratch = new Uint8Array(Math.min(CHUNK, inode.size));
+          let copied = 0;
+          while (copied < inode.size) {
+            const n = Math.min(CHUNK, inode.size - copied);
+            const slice = n < scratch.length ? scratch.subarray(0, n) : scratch;
+            this.handle.read(slice, { at: oldBase + copied });
+            this.handle.write(slice, { at: newBase + copied });
+            copied += n;
+          }
+        }
+        this.freeBlockRange(inode.firstBlock, inode.blockCount);
+        this.zeroFileRange(newBase + inode.size, len - inode.size);
         inode.firstBlock = newFirst;
+      } else {
+        this.zeroFileRange(
+          this.dataOffset + inode.firstBlock * this.blockSize + inode.size,
+          len - inode.size
+        );
       }
       inode.blockCount = neededBlocks;
       inode.size = len;
@@ -1149,14 +1265,45 @@ var VFSEngine = class {
     if (flags & 1 && this.pathIndex.has(destPath)) {
       return { status: CODE_TO_STATUS.EEXIST };
     }
-    const data = srcInode.size > 0 ? this.readData(srcInode.firstBlock, srcInode.blockCount, srcInode.size) : new Uint8Array(0);
-    return this.write(destPath, data);
+    if (srcPath === destPath) return { status: 0 };
+    const srcSize = srcInode.size;
+    const srcFirstBlock = srcInode.firstBlock;
+    const emptyStatus = this.write(destPath, new Uint8Array(0));
+    if (emptyStatus.status !== 0) return emptyStatus;
+    if (srcSize === 0) return { status: 0 };
+    const destIdx = this.resolvePathComponents(destPath, true);
+    if (destIdx === void 0) return { status: CODE_TO_STATUS.EIO };
+    const destInode = this.readInode(destIdx);
+    const neededBlocks = Math.ceil(srcSize / this.blockSize);
+    const newFirst = this.allocateBlocks(neededBlocks);
+    const newBase = this.dataOffset + newFirst * this.blockSize;
+    const srcBase = this.dataOffset + srcFirstBlock * this.blockSize;
+    const CHUNK = 4 * 1024 * 1024;
+    const scratch = new Uint8Array(Math.min(CHUNK, srcSize));
+    let copied = 0;
+    while (copied < srcSize) {
+      const n = Math.min(CHUNK, srcSize - copied);
+      const slice = n < scratch.length ? scratch.subarray(0, n) : scratch;
+      this.handle.read(slice, { at: srcBase + copied });
+      this.handle.write(slice, { at: newBase + copied });
+      copied += n;
+    }
+    destInode.firstBlock = newFirst;
+    destInode.blockCount = neededBlocks;
+    destInode.size = srcSize;
+    destInode.mtime = Date.now();
+    this.writeInode(destIdx, destInode);
+    this.commitPending();
+    return { status: 0 };
   }
   // ---- ACCESS ----
   access(path, mode = 0) {
     path = this.normalizePath(path);
     const idx = this.resolvePathComponents(path, true);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT };
+    if (idx === void 0) {
+      if (this.isImplicitDirectory(path)) return { status: 0 };
+      return { status: CODE_TO_STATUS.ENOENT };
+    }
     if (mode === 0) return { status: 0 };
     if (!this.strictPermissions) return { status: 0 };
     const inode = this.readInode(idx);
@@ -1176,7 +1323,12 @@ var VFSEngine = class {
   realpath(path) {
     path = this.normalizePath(path);
     const idx = this.resolvePathComponents(path, true);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
+    if (idx === void 0) {
+      if (this.isImplicitDirectory(path)) {
+        return { status: 0, data: encoder.encode(path) };
+      }
+      return { status: CODE_TO_STATUS.ENOENT, data: null };
+    }
     const inode = this.readInode(idx);
     const resolvedPath = this.readPath(inode.pathOffset, inode.pathLength);
     return { status: 0, data: encoder.encode(resolvedPath) };
@@ -1314,16 +1466,35 @@ var VFSEngine = class {
     if (endPos > inode.size) {
       const neededBlocks = Math.ceil(endPos / this.blockSize);
       if (neededBlocks > inode.blockCount) {
-        const oldData = inode.size > 0 ? this.readData(inode.firstBlock, inode.blockCount, inode.size) : new Uint8Array(0);
-        this.freeBlockRange(inode.firstBlock, inode.blockCount);
         const newFirst = this.allocateBlocks(neededBlocks);
-        const newBuf = new Uint8Array(endPos);
-        newBuf.set(oldData);
-        newBuf.set(data, pos);
-        this.writeData(newFirst, newBuf);
+        const newBase = this.dataOffset + newFirst * this.blockSize;
+        const oldBase = this.dataOffset + inode.firstBlock * this.blockSize;
+        if (inode.size > 0) {
+          const CHUNK = 4 * 1024 * 1024;
+          const scratch = new Uint8Array(Math.min(CHUNK, inode.size));
+          let copied = 0;
+          while (copied < inode.size) {
+            const n = Math.min(CHUNK, inode.size - copied);
+            const slice = n < scratch.length ? scratch.subarray(0, n) : scratch;
+            this.handle.read(slice, { at: oldBase + copied });
+            this.handle.write(slice, { at: newBase + copied });
+            copied += n;
+          }
+        }
+        this.freeBlockRange(inode.firstBlock, inode.blockCount);
+        if (pos > inode.size) {
+          this.zeroFileRange(newBase + inode.size, pos - inode.size);
+        }
+        this.handle.write(data, { at: newBase + pos });
         inode.firstBlock = newFirst;
         inode.blockCount = neededBlocks;
       } else {
+        if (pos > inode.size) {
+          this.zeroFileRange(
+            this.dataOffset + inode.firstBlock * this.blockSize + inode.size,
+            pos - inode.size
+          );
+        }
         const dataOffset = this.dataOffset + inode.firstBlock * this.blockSize + pos;
         this.handle.write(data, { at: dataOffset });
       }
@@ -1346,6 +1517,7 @@ var VFSEngine = class {
   fstat(fd) {
     const entry = this.fdTable.get(fd);
     if (!entry) return { status: CODE_TO_STATUS.EBADF, data: null };
+    if (entry.implicitPath) return this.encodeImplicitDirStatResponse(entry.implicitPath);
     return this.encodeStatResponse(entry.inodeIdx);
   }
   // ---- FTRUNCATE ----
@@ -1368,6 +1540,7 @@ var VFSEngine = class {
   fchmod(fd, mode) {
     const entry = this.fdTable.get(fd);
     if (!entry) return { status: CODE_TO_STATUS.EBADF };
+    if (entry.implicitPath) return { status: 0 };
     const inode = this.readInode(entry.inodeIdx);
     inode.mode = inode.mode & S_IFMT | mode & 4095;
     inode.ctime = Date.now();
@@ -1378,6 +1551,7 @@ var VFSEngine = class {
   fchown(fd, uid, gid) {
     const entry = this.fdTable.get(fd);
     if (!entry) return { status: CODE_TO_STATUS.EBADF };
+    if (entry.implicitPath) return { status: 0 };
     const inode = this.readInode(entry.inodeIdx);
     inode.uid = uid;
     inode.gid = gid;
@@ -1389,6 +1563,7 @@ var VFSEngine = class {
   futimes(fd, atime, mtime) {
     const entry = this.fdTable.get(fd);
     if (!entry) return { status: CODE_TO_STATUS.EBADF };
+    if (entry.implicitPath) return { status: 0 };
     const inode = this.readInode(entry.inodeIdx);
     inode.atime = atime;
     inode.mtime = mtime;
@@ -1400,7 +1575,16 @@ var VFSEngine = class {
   opendir(path, tabId2) {
     path = this.normalizePath(path);
     const idx = this.resolvePathComponents(path, true);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
+    if (idx === void 0) {
+      if (this.isImplicitDirectory(path)) {
+        const fd2 = this.nextFd++;
+        this.fdTable.set(fd2, { tabId: tabId2, inodeIdx: -1, position: 0, flags: 0, implicitPath: path });
+        const buf2 = new Uint8Array(4);
+        new DataView(buf2.buffer).setUint32(0, fd2, true);
+        return { status: 0, data: buf2 };
+      }
+      return { status: CODE_TO_STATUS.ENOENT, data: null };
+    }
     const inode = this.readInode(idx);
     if (inode.type !== INODE_TYPE.DIRECTORY) return { status: CODE_TO_STATUS.ENOTDIR, data: null };
     const fd = this.nextFd++;
@@ -1439,6 +1623,106 @@ var VFSEngine = class {
     }
     return children.sort();
   }
+  /**
+   * Rebuild the set of all implicit directory paths.
+   * An implicit directory is any ancestor path of a file/symlink in pathIndex
+   * that doesn't itself have an explicit inode entry.
+   * Only rebuilt when pathIndex has changed (tracked via generation counter).
+   */
+  rebuildImplicitDirs() {
+    if (this.implicitDirsGen === this.pathIndexGen) return;
+    const now = Date.now();
+    const prev = this.implicitDirs;
+    this.implicitDirs = /* @__PURE__ */ new Map();
+    for (const filePath of this.pathIndex.keys()) {
+      let pos = filePath.length;
+      while (true) {
+        pos = filePath.lastIndexOf("/", pos - 1);
+        if (pos <= 0) break;
+        const ancestor = filePath.substring(0, pos);
+        if (this.implicitDirs.has(ancestor)) break;
+        if (!this.pathIndex.has(ancestor)) {
+          this.implicitDirs.set(ancestor, prev.get(ancestor) ?? now);
+        }
+      }
+    }
+    this.implicitDirsGen = this.pathIndexGen;
+  }
+  /**
+   * Check if a path is an implicit directory (exists because files exist under it,
+   * but no explicit directory inode was created for it).
+   */
+  isImplicitDirectory(path) {
+    if (path === "/") return false;
+    this.rebuildImplicitDirs();
+    return this.implicitDirs.has(path);
+  }
+  /**
+   * Get direct children of a directory path, including implicit subdirectories.
+   * Returns unique child full paths. Each entry is tagged with whether it's a
+   * real inode or an implicit directory.
+   */
+  getDirectChildrenWithImplicit(dirPath) {
+    const prefix = dirPath === "/" ? "/" : dirPath + "/";
+    const childNames = /* @__PURE__ */ new Map();
+    for (const path of this.pathIndex.keys()) {
+      if (path === dirPath) continue;
+      if (!path.startsWith(prefix)) continue;
+      const rest = path.substring(prefix.length);
+      const slashPos = rest.indexOf("/");
+      if (slashPos === -1) {
+        childNames.set(rest, "real");
+      } else {
+        const childName = rest.substring(0, slashPos);
+        if (!childNames.has(childName)) {
+          const childFullPath = prefix + childName;
+          childNames.set(childName, this.pathIndex.has(childFullPath) ? "real" : "implicit");
+        }
+      }
+    }
+    const result = [];
+    for (const [name, type] of childNames) {
+      result.push({ path: prefix + name, type });
+    }
+    result.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return result;
+  }
+  /**
+   * Encode a synthetic stat response for an implicit directory.
+   * Returns directory stats with default mode, zero size, current timestamps.
+   */
+  encodeImplicitDirStatResponse(path) {
+    this.rebuildImplicitDirs();
+    const ts = this.implicitDirs.get(path) ?? Date.now();
+    const mode = DEFAULT_DIR_MODE & ~(this.umask & 511);
+    const children = this.getDirectChildrenWithImplicit(path);
+    let subdirCount = 0;
+    for (const child of children) {
+      if (child.type === "implicit") {
+        subdirCount++;
+      } else {
+        const childIdx = this.pathIndex.get(child.path);
+        if (childIdx !== void 0) {
+          const childInode = this.readInode(childIdx);
+          if (childInode.type === INODE_TYPE.DIRECTORY) subdirCount++;
+        }
+      }
+    }
+    const nlink = 2 + subdirCount;
+    const buf = new Uint8Array(53);
+    const view = new DataView(buf.buffer);
+    view.setUint8(0, INODE_TYPE.DIRECTORY);
+    view.setUint32(1, mode, true);
+    view.setFloat64(5, 0, true);
+    view.setFloat64(13, ts, true);
+    view.setFloat64(21, ts, true);
+    view.setFloat64(29, ts, true);
+    view.setUint32(37, this.processUid, true);
+    view.setUint32(41, this.processGid, true);
+    view.setUint32(45, 0, true);
+    view.setUint32(49, nlink, true);
+    return { status: 0, data: buf };
+  }
   getAllDescendants(dirPath) {
     const prefix = dirPath === "/" ? "/" : dirPath + "/";
     const descendants = [];
@@ -1456,7 +1740,10 @@ var VFSEngine = class {
     if (lastSlash <= 0) return 0;
     const parentPath = path.substring(0, lastSlash);
     const parentIdx = this.pathIndex.get(parentPath);
-    if (parentIdx === void 0) return CODE_TO_STATUS.ENOENT;
+    if (parentIdx === void 0) {
+      if (this.isImplicitDirectory(parentPath)) return 0;
+      return CODE_TO_STATUS.ENOENT;
+    }
     const parentInode = this.readInode(parentIdx);
     if (parentInode.type !== INODE_TYPE.DIRECTORY) return CODE_TO_STATUS.ENOTDIR;
     return 0;