@ai-ecoverse/slicc-kernel 1.125.10 → 1.125.12

package/dist/node.js

@@ -4359,6 +4359,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",
@@ -5714,15 +5715,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(parentOf4(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(parentOf4))];
+    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(parentOf4(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(parentOf4(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, parentOf4(e.path)])
+    );
+    for (const entry of checked) {
+      const stale = entry.link === void 0 ? !await real(entry.path) : await real(entry.path) || !await real(parentOf4(entry.path));
       if (!stale) continue;
       const seen = JSON.stringify(entry);
       await this.meta.update(
@@ -7110,7 +7153,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.125.10" : "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
@@ -18386,9 +18429,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) {
@@ -18434,7 +18489,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);
@@ -18477,7 +18532,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;
     }
@@ -18546,8 +18601,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;
@@ -19291,6 +19347,7 @@ var MAX_READ = 1024 * 1024;
 var O_NONBLOCK = 2048;
 var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
+var STUCK_ESCAPES = /* @__PURE__ */ new Set([SIG.INT, SIG.TERM, SIG.QUIT, SIG.HUP]);
 var DEFAULT_UMASK2 = 18;
 function words(value2) {
   if (!Array.isArray(value2) || !value2.every((w) => typeof w === "string")) {
@@ -19347,6 +19404,8 @@ var WasmProcess = class {
   cred;
   execChild;
   killed = false;
+  calls = 0;
+  pendingAt = /* @__PURE__ */ new Map();
   execTermsig;
   stopped = 0;
   stops = 0;
@@ -19445,9 +19504,9 @@ var WasmProcess = class {
       const action = defaultAction(sig);
       return action === "stop" ? this.stop(sig) : action;
     }
-    if (((this.options.pendingBits?.() ?? 0) & bit) !== 0 && defaultAction(sig) === "terminate") {
-      return "terminate";
-    }
+    if (((this.options.pendingBits?.() ?? 0) & bit) !== 0) {
+      if (STUCK_ESCAPES.has(sig) && this.pendingAt.get(sig) === this.calls) return "terminate";
+    } else this.pendingAt.set(sig, this.calls);
     this.options.onPending?.(sig);
     if (this.options.jobs?.keyboard && KEYBOARD.has(sig) && this.waiting.size === 0)
       this.owed = true;
@@ -19570,6 +19629,7 @@ var WasmProcess = class {
   }
   async syscall(req, cancelled, block) {
     this.options.onSyscall?.(req);
+    this.calls += 1;
     const started = performance.now();
     let restarted = false;
     for (; ; ) {