@ai-ecoverse/slicc-kernel 1.146.4 → 1.146.7

package/dist/node.js

@@ -3305,7 +3305,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.146.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.146.7" : "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
@@ -19829,15 +19829,7 @@ var WasmProcess = class {
           }
         });
       } else {
-        await this.unmissed(
-          () => this.openPath(req, marked),
-          async (at) => {
-            await this.stillOpen(at, req.handle);
-            return nodes.identify(at);
-          },
-          (id2, at) => this.fds.installAt(fd, this.openVfsFile({ ...open, path: at }, id2, fs)),
-          { at: path, gen }
-        );
+        await this.openExisting(req, marked, fd, open, fs, { at: path, gen });
       }
       if (req.existing && !await present3(fs, path, true)) {
         throw new KernelError("ENOENT");
@@ -19897,7 +19889,22 @@ var WasmProcess = class {
     const inherited2 = req.orphan || req.contents !== void 0 || req.handle !== void 0;
     if (guard2?.links === void 0 || !noLinks || inherited2 || req.pin !== void 0)
       return void 0;
-    return (await walk(guard2.fs, this.cred, req.path, !req.exclusive, guard2.links)).path;
+    const follow2 = !req.exclusive && req.nofollow !== true;
+    return (await walk(guard2.fs, this.cred, req.path, follow2, guard2.links)).path;
+  }
+  async openExisting(req, marked, fd, open, fs, first) {
+    const nodes = this.nodes;
+    const own = unfollowed(req);
+    await this.unmissed(
+      this.openPath.bind(this, req, marked),
+      async (at) => {
+        if (own) await notLink(this.options.fs, at);
+        await this.stillOpen(at, req.handle);
+        return nodes.identify(at);
+      },
+      (id2, at) => this.fds.installAt(fd, this.openVfsFile({ ...open, path: at }, id2, fs)),
+      first
+    );
   }
   async openPath(req, marked) {
     const nodes = this.nodes;
@@ -19905,6 +19912,7 @@ var WasmProcess = class {
     if (req.exclusive) return nodes.entryKey(marked ?? req.path);
     if (marked !== void 0) return marked;
     if (req.create) return nodes.targetKey(req.path);
+    if (unfollowed(req)) return nodes.entryKey(req.path);
     return this.keptOr(await nodes.targetKey(req.path), req.handle);
   }
   async mayOpen(req) {
@@ -20200,7 +20208,9 @@ var WasmProcess = class {
       given = void 0;
       await r?.settled(at);
       const found = await look(at);
-      if (!r || !r.missed(at) && !r.changedSince(at, gen)) return make(found, at);
+      if (!r || !r.missed(at) && !r.changedSince(at, gen) && !r.inFlight?.(at)) {
+        return make(found, at);
+      }
     }
   }
   async stillOpen(at, handle) {
@@ -20728,6 +20738,13 @@ var WasmProcess = class {
     await this.options.http?.closeAll();
   }
 };
+function unfollowed(req) {
+  return req.nofollow === true && req.handle === void 0;
+}
+async function notLink(fs, path) {
+  const st = await fs.lstat?.(path);
+  if (st?.isSymbolicLink) throw new KernelError("ELOOP");
+}
 
 // src/kernel/protocol.ts
 var WASM_PROCESS_INIT = "wasm-process-init";
@@ -23359,6 +23376,28 @@ function prefixes(path) {
 function within9(path, root) {
   return path === root || path.startsWith(`${root}/`);
 }
+var unstored = () => Object.assign(new Error("the file system kept fewer bytes than were written"), {
+  code: "ENOSPC"
+});
+var CHECKED_BYTES = 16 * 1024 * 1024;
+var Extent = class {
+  floor = 0;
+  exact;
+  wrote(end) {
+    this.floor = Math.max(this.floor, end);
+    if (this.exact !== void 0) this.exact = Math.max(this.exact, end);
+  }
+  cut(size) {
+    this.exact = size;
+    this.floor = Math.min(this.floor, size);
+  }
+  big() {
+    return Math.max(this.floor, this.exact ?? 0) >= CHECKED_BYTES;
+  }
+  check(size) {
+    if (size < this.floor || this.exact !== void 0 && size < this.exact) throw unstored();
+  }
+};
 var LOCKED = /* @__PURE__ */ new Set(["NotReadableError", "NoModificationAllowedError", "InvalidStateError"]);
 var SYNC_BACKOFF_MS = [5, 10, 20, 40, 80];
 async function openSync(handle) {
@@ -23384,14 +23423,22 @@ function writeAll5(access2, at, bytes) {
   }
 }
 async function positioned(handle, op) {
+  const extent = new Extent();
   const access2 = await openSync(handle);
   if (access2) {
     try {
       op({
-        write: (at, bytes) => writeAll5(access2, at, bytes),
-        truncate: (n) => access2.truncate(n)
+        write: (at, bytes) => {
+          writeAll5(access2, at, bytes);
+          extent.wrote(at + bytes.length);
+        },
+        truncate: (n) => {
+          access2.truncate(n);
+          extent.cut(n);
+        }
       });
       access2.flush();
+      if (access2.getSize) extent.check(access2.getSize());
     } finally {
       access2.close();
     }
@@ -23400,14 +23447,25 @@ async function positioned(handle, op) {
   const writable2 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
-      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }),
-      truncate: (n) => writable2.truncate(n)
+      write: async (at, bytes) => {
+        await writable2.write({
+          type: "write",
+          position: at,
+          data: bytes
+        });
+        extent.wrote(at + bytes.length);
+      },
+      truncate: async (n) => {
+        await writable2.truncate(n);
+        extent.cut(n);
+      }
     });
   } catch (err) {
     await writable2.abort();
     throw err;
   }
   await writable2.close();
+  if (extent.big()) extent.check((await handle.getFile()).size);
 }
 function isHandle(child) {
   return "kind" in child;
@@ -24382,6 +24440,11 @@ var OpfsFs = class {
       writable2 = await this.io(file.createWritable());
       await writable2.write(content);
       await writable2.close();
+      if (typeof content !== "string" && content.length >= CHECKED_BYTES) {
+        const extent = new Extent();
+        extent.cut(content.length);
+        extent.check((await file.getFile()).size);
+      }
     } catch (err) {
       await writable2?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
@@ -25154,13 +25217,7 @@ var OpfsFs = class {
     }
   }
   async place(handle, dir, name2, copies) {
-    const move = handle.move;
-    if (move) this.others++;
-    const moved2 = await move?.call(handle, dir, name2).then(
-      () => true,
-      () => false
-    );
-    if (moved2) return true;
+    if (await this.moved(handle, dir, name2)) return true;
     const before = this.fileMoves;
     try {
       await this.copy(handle, dir, name2, copies);
@@ -25173,6 +25230,23 @@ var OpfsFs = class {
     return false;
   }
   fileMoves = 0;
+  async moved(handle, dir, name2) {
+    const move = handle.move;
+    if (!move) return false;
+    for (let attempt = 0; ; attempt++) {
+      this.others++;
+      const failed3 = await move.call(handle, dir, name2).then(
+        () => void 0,
+        (err) => ({ err })
+      );
+      if (!failed3) return true;
+      const error = failed3.err?.name;
+      if (handle.kind !== "file" || !LOCKED.has(error)) return false;
+      const delay = SYNC_BACKOFF_MS[attempt];
+      if (delay === void 0) throw fsError("EBUSY", name2);
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
+    }
+  }
   async copy(handle, dir, name2, copies, rest2 = "") {
     if (handle.kind === "file" && movable(handle)) {
       this.others++;