@componentor/fs 3.0.21 → 3.0.23

package/dist/index.d.mts

@@ -232,6 +232,8 @@ declare class VFSFileSystem {
      *  The readyPromise will resolve once OPFS mode is ready, but init()
      *  will reject with the corruption error to inform the caller. */
     private handleCorruptVFS;
+    /** Initialize the async-relay worker. Called after sync-relay signals ready. */
+    private initAsyncRelay;
     /** Start as leader — tell sync-relay to init VFS engine + OPFS handle */
     private startAsLeader;
     /** Start as follower — connect to leader via service worker port brokering */

package/dist/index.js

@@ -1381,6 +1381,7 @@ var VFSFileSystem = class {
       const msg = e.data;
       if (msg.type === "ready") {
         this.isReady = true;
+        this.initAsyncRelay();
         this.resolveReady();
         if (!this.isFollower) {
           this.initLeaderBroker();
@@ -1405,23 +1406,6 @@ var VFSFileSystem = class {
         }
       }
     };
-    if (this.hasSAB) {
-      this.asyncWorker.postMessage({
-        type: "init-leader",
-        asyncSab: this.asyncSab,
-        wakeSab: this.sab
-      });
-    } else {
-      const mc = new MessageChannel();
-      this.asyncWorker.postMessage(
-        { type: "init-port", port: mc.port1 },
-        [mc.port1]
-      );
-      this.syncWorker.postMessage(
-        { type: "async-port", port: mc.port2 },
-        [mc.port2]
-      );
-    }
     this.acquireLeaderLock();
   }
   /** Use Web Locks API for leader election. The tab that acquires the lock is
@@ -1516,6 +1500,26 @@ var VFSFileSystem = class {
     this._mode = "opfs";
     this.sendOPFSInit();
   }
+  /** Initialize the async-relay worker. Called after sync-relay signals ready. */
+  initAsyncRelay() {
+    if (this.hasSAB) {
+      this.asyncWorker.postMessage({
+        type: "init-leader",
+        asyncSab: this.asyncSab,
+        wakeSab: this.sab
+      });
+    } else {
+      const mc = new MessageChannel();
+      this.asyncWorker.postMessage(
+        { type: "init-port", port: mc.port1 },
+        [mc.port1]
+      );
+      this.syncWorker.postMessage(
+        { type: "async-port", port: mc.port2 },
+        [mc.port2]
+      );
+    }
+  }
   /** Start as leader — tell sync-relay to init VFS engine + OPFS handle */
   startAsLeader() {
     this.isFollower = false;
@@ -2695,6 +2699,16 @@ var VFSEngine = class {
   }
   /** Resolve symlinks in intermediate path components */
   resolvePathComponents(path, followLast = true, depth = 0) {
+    const result = this.resolvePathFull(path, followLast, depth);
+    return result?.idx;
+  }
+  /**
+   * Resolve a path following symlinks, returning both the inode index AND the
+   * fully resolved path. This is needed by readdir: when listing a symlinked
+   * directory, we must search for children under the resolved target path
+   * (where files actually exist in pathIndex), not under the symlink path.
+   */
+  resolvePathFull(path, followLast = true, depth = 0) {
     if (depth > MAX_SYMLINK_DEPTH) return void 0;
     const parts = path.split("/").filter(Boolean);
     let current = "/";
@@ -2708,14 +2722,16 @@ var VFSEngine = class {
         const target = decoder8.decode(this.readData(inode.firstBlock, inode.blockCount, inode.size));
         const resolved = target.startsWith("/") ? target : this.resolveRelative(current, target);
         if (isLast) {
-          return this.resolvePathComponents(resolved, true, depth + 1);
+          return this.resolvePathFull(resolved, true, depth + 1);
         }
         const remaining = parts.slice(i + 1).join("/");
         const newPath = resolved + (remaining ? "/" + remaining : "");
-        return this.resolvePathComponents(newPath, followLast, depth + 1);
+        return this.resolvePathFull(newPath, followLast, depth + 1);
       }
     }
-    return this.pathIndex.get(current);
+    const finalIdx = this.pathIndex.get(current);
+    if (finalIdx === void 0) return void 0;
+    return { idx: finalIdx, resolvedPath: current };
   }
   resolveRelative(from, target) {
     const dir = from.substring(0, from.lastIndexOf("/")) || "/";
@@ -2914,10 +2930,10 @@ var VFSEngine = class {
     if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
     return this.encodeStatResponse(idx);
   }
-  // ---- LSTAT (no symlink follow) ----
+  // ---- LSTAT (no symlink follow for the FINAL component) ----
   lstat(path) {
     path = this.normalizePath(path);
-    const idx = this.pathIndex.get(path);
+    const idx = this.resolvePathComponents(path, false);
     if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
     return this.encodeStatResponse(idx);
   }
@@ -3004,12 +3020,12 @@ var VFSEngine = class {
   // ---- READDIR ----
   readdir(path, flags = 0) {
     path = this.normalizePath(path);
-    const idx = this.resolvePathComponents(path, true);
-    if (idx === void 0) return { status: CODE_TO_STATUS.ENOENT, data: null };
-    const inode = this.readInode(idx);
+    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 };
     const withFileTypes = (flags & 1) !== 0;
-    const children = this.getDirectChildren(path);
+    const children = this.getDirectChildren(resolved.resolvedPath);
     if (withFileTypes) {
       let totalSize2 = 4;
       const entries = [];