@ai-ecoverse/slicc-kernel 1.125.11 → 1.125.12

package/dist/kernel-worker.js

@@ -1096,6 +1096,7 @@ var ABSENT_NAMES = 4096;
 var FILE_HANDLES = 4096;
 var STALE = /* @__PURE__ */ new Set(["NotFoundError", "TypeMismatchError"]);
 var REPLACED_ATTEMPTS = 4;
+var RECONCILE_LISTINGS = 8;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
@@ -2455,15 +2456,57 @@ var OpfsFs = class {
       timesBy: this.id
     }));
   }
+  async present(paths) {
+    const listed = /* @__PURE__ */ new Map();
+    const done4 = /* @__PURE__ */ new Map();
+    const list = (dir) => {
+      const known = listed.get(dir);
+      if (known !== void 0) return known;
+      const listing = (async () => {
+        const above = dir === "/" ? void 0 : await list(parentOf3(dir));
+        if (above === null) return null;
+        const handle = dir === "/" ? this.root : above?.get(baseOf(dir));
+        if (handle?.kind !== "directory") return void 0;
+        this.calls++;
+        const children3 = /* @__PURE__ */ new Map();
+        try {
+          for await (const child of handle.values())
+            children3.set(child.name, child);
+        } catch {
+          return null;
+        }
+        return children3;
+      })().then((children3) => {
+        done4.set(dir, children3);
+        return children3;
+      });
+      listed.set(dir, listing);
+      return listing;
+    };
+    const dirs = [...new Set(paths.filter((p) => split(p).length > 0).map(parentOf3))];
+    let next3 = 0;
+    const lister = async () => {
+      while (next3 < dirs.length) await list(dirs[next3++]);
+    };
+    await Promise.all(Array.from({ length: Math.min(RECONCILE_LISTINGS, dirs.length) }, lister));
+    return async (path) => {
+      if (split(path).length === 0) return true;
+      const listing = done4.get(parentOf3(path));
+      if (listing === null) return this.real(path);
+      return listing?.has(baseOf(path)) === true;
+    };
+  }
   async reconcile() {
     if (this.remote && await this.remote.peered()) return 0;
     let removed = 0;
     const entries = await this.meta.all();
     const carried = new Set(entries.filter((e) => !e.vacated).map((e) => e.ino));
-    for (const entry of entries) {
-      if (entry.vacated && carried.has(inodeOf(entry.path))) continue;
-      const real = await this.real(entry.path);
-      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf3(entry.path));
+    const checked = entries.filter((e) => !(e.vacated && carried.has(inodeOf(e.path))));
+    const real = await this.present(
+      checked.flatMap((e) => e.link === void 0 ? [e.path] : [e.path, parentOf3(e.path)])
+    );
+    for (const entry of checked) {
+      const stale = entry.link === void 0 ? !await real(entry.path) : await real(entry.path) || !await real(parentOf3(entry.path));
       if (!stale) continue;
       const seen = JSON.stringify(entry);
       await this.meta.update(
@@ -6656,7 +6699,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.125.11" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.125.12" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -18449,9 +18492,21 @@ var VfsNode = class {
   }
   async keep() {
     const ranged2 = await this.prepare();
-    await ranged2?.pin();
+    if (ranged2) await this.followed(() => ranged2.pin());
   }
   moving = /* @__PURE__ */ new Set();
+  async followed(op) {
+    for (; ; ) {
+      const at = this.path;
+      try {
+        return await op();
+      } catch (err) {
+        if (!isMissing(err)) throw err;
+        while (this.moving.size > 0) await Promise.all(this.moving);
+        if (this.path === at) throw err;
+      }
+    }
+  }
   async load() {
     if (this.revoked) throw new KernelError("EIO");
     while (!this.data) {
@@ -18497,7 +18552,7 @@ var VfsNode = class {
   }
   async pread(max, at) {
     const ranged2 = await this.prepare();
-    if (ranged2) return ranged2.read(at, max);
+    if (ranged2) return this.followed(() => ranged2.read(at, max));
     const bytes = await this.load();
     const n = Math.max(0, Math.min(max, this.length - at));
     return bytes.slice(at, at + n);
@@ -18540,7 +18595,7 @@ var VfsNode = class {
     await this.fits(at + bytes.length);
     const ranged2 = await this.prepare();
     if (ranged2) {
-      await ranged2.write(at, bytes);
+      await this.followed(() => ranged2.write(at, bytes));
       this.markDirty();
       return bytes.length;
     }
@@ -18609,8 +18664,9 @@ var VfsNode = class {
     this.dirty = false;
     const started = performance.now();
     try {
-      if (this.ranged) await this.ranged.flush();
-      else await this.fs.writeFile(this.path, this.data.slice(0, this.length));
+      await this.followed(
+        () => this.ranged ? this.ranged.flush() : this.fs.writeFile(this.path, this.data.slice(0, this.length))
+      );
     } catch (err) {
       this.dirty = true;
       throw err;