@ai-ecoverse/slicc-kernel 1.62.0 → 1.62.1

package/dist/process-worker.js

@@ -1640,7 +1640,10 @@ function errnoError(code2, path) {
 }
 function createSyncFsSabBridge(transport, opts = {}) {
   const timeoutMs = opts.timeoutMs ?? SYNC_FS_REQUEST_TIMEOUT_MS;
+  let identity = {};
+  let last = null;
   function run(req, path, transfer) {
+    last = null;
     const result = transport.call(req, timeoutMs, `sync-sab bridge, '${path}'`, transfer);
     if (!result.ok) throw errnoError(result.errno, path);
     return result;
@@ -1655,20 +1658,24 @@ function createSyncFsSabBridge(transport, opts = {}) {
     if (r.ok && r.kind === "json") return r.json;
     throw errnoError("EIO", path);
   }
+  const changing = (req, path, transfer) => {
+    const r = run({ ...req, ...identity }, path, transfer);
+    if (r.ok && r.kind === "json") last = parseSyncFsStat(r.json);
+  };
   const io = (id) => ({
     readFile: (path) => bytes({ op: "read", path, ...id }, path),
     writeFile: (path, data, open) => {
-      run({ op: "write", path, body: data, ...open ? { mode: 1 } : {}, ...id }, path);
+      changing({ op: "write", path, body: data, ...open ? { mode: 1 } : {}, ...id }, path);
     },
     pread: (path, offset, length, version) => bytes({ op: "pread", path, offset, length, ...version ? { version } : {}, ...id }, path),
     pwrite: (path, offset, body, transfer) => {
       const whole = body.byteOffset === 0 && body.byteLength === body.buffer.byteLength;
       const owned = transfer && whole && body.buffer instanceof ArrayBuffer;
       const transferred = owned ? [body.buffer] : [];
-      run({ op: "pwrite", path, offset, body, ...id }, path, transferred);
+      changing({ op: "pwrite", path, offset, body, ...id }, path, transferred);
     },
     truncate: (path, length) => {
-      run({ op: "truncate", path, length, ...id }, path);
+      changing({ op: "truncate", path, length, ...id }, path);
     }
   });
   return {
@@ -1740,11 +1747,15 @@ function createSyncFsSabBridge(transport, opts = {}) {
       return target;
     },
     chmod: (path, mode) => {
-      run({ op: "chmod", path, mode }, path);
+      changing({ op: "chmod", path, mode }, path);
     },
     utimes: (path, atimeMs, mtimeMs) => {
-      run({ op: "utimes", path, atimeMs, mtimeMs }, path);
+      changing({ op: "utimes", path, atimeMs, mtimeMs }, path);
+    },
+    identify: () => {
+      identity = { identity: true };
     },
+    identified: () => last,
     lutimes: (path, atimeMs, mtimeMs) => {
       run({ op: "lutimes", path, atimeMs, mtimeMs }, path);
     },
@@ -1753,7 +1764,7 @@ function createSyncFsSabBridge(transport, opts = {}) {
     },
     chown: (path, uid, gid, follow2) => {
       const ids = { ...uid !== void 0 ? { uid } : {}, ...gid !== void 0 ? { gid } : {} };
-      run({ op: follow2 ? "chown" : "lchown", path, ...ids }, path);
+      changing({ op: follow2 ? "chown" : "lchown", path, ...ids }, path);
     },
     ...opts.owners ? { owners: true } : {},
     hold: (path, held, open, handle) => {
@@ -4722,7 +4733,26 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
       cache.mutated(paths);
     }
   };
+  let exact = false;
+  const threaded = () => {
+    if (blind || shared === void 0 || !bridge.identify) return;
+    exact = true;
+    bridge.identify();
+  };
+  const identified = (p, op, also) => {
+    const before = cache.generation();
+    try {
+      return op();
+    } finally {
+      const st = bridge.identified?.() ?? null;
+      if (!st) cache.mutated([]);
+      else if (cache.mutated([p, ...also], st.ino) === before + 1 + also.length && !st.isSymbolicLink) {
+        cache.put(stats, p, st);
+      }
+    }
+  };
   const rewriting = (p, op, ...also) => {
+    if (exact) return identified(p, op, also);
     const ino = cache.inoOf(p, () => bridge.stat(p));
     try {
       return op();
@@ -4781,7 +4811,8 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
     } : {},
     ...bridge.owners ? { owners: true } : {},
     invalidate,
-    touched
+    touched,
+    threaded
   };
 }
 function pinnedIo2(bridge, handle, rewriting) {
@@ -5030,11 +5061,15 @@ var init_wasi_files = __esm({
       }
       mutated(paths, ino = 0) {
         this.clear();
-        if (!this.shared) return;
+        if (!this.shared) return 0;
         const key = ino % 4294967296 | 0;
         for (const [i, hash] of (paths.length > 0 ? paths.map(pathHash) : [0]).entries()) {
           this.seen = this.publish(this.shared, hash, i === 0 ? key : 0);
         }
+        return this.seen;
+      }
+      generation() {
+        return this.shared ? Atomics.load(this.shared, FS_GEN) : 0;
       }
       inoOf(path, look) {
         if (!this.shared) return 0;
@@ -5265,6 +5300,7 @@ var init_wasi_fds = __esm({
           this.cloexec.clear();
         }
         this.shared = ids;
+        this.fs.threaded?.();
         this.seen = Atomics.load(ids, GEN);
       }
       sync() {
@@ -5589,6 +5625,14 @@ var init_wasi_fds = __esm({
         this.detach(buffer, linked);
         this.buffers.delete(path);
       }
+      openedIno(fd) {
+        try {
+          return this.kernel.call({ op: "fd-vfs-stat", fd, identity: true }).ino;
+        } catch (err) {
+          this.kernel.sys.close(fd);
+          throw err;
+        }
+      }
       inoOf(path) {
         try {
           return this.fs.stat(path).ino;
@@ -5682,10 +5726,10 @@ var init_wasi_fds = __esm({
         if (e.path !== void 0 || this.learned.has(e)) return;
         this.learned.add(e);
         try {
-          const vfs = this.kernel.call({ op: "fd-vfs-stat", fd });
+          const vfs = this.kernel.call({ op: "fd-vfs-stat", fd, identity: true });
           if (vfs.orphan || vfs.path === void 0) return;
           e.path = vfs.path;
-          e.ino = this.inoOf(vfs.path);
+          e.ino = vfs.ino ?? this.inoOf(vfs.path);
         } catch {
         }
       }
@@ -5723,9 +5767,8 @@ var init_wasi_fds = __esm({
         const made = !existing && this.createNew(path, oflags);
         const truncate = made || (oflags & OFLAGS.TRUNC) !== 0;
         const fd = this.kernel.sys.openVfs(path, flags, 0, truncate ? { truncate } : {});
-        const was = existing && this.inoOf(path);
-        if (truncate) this.fs.touched?.(path, was);
-        const ino = existing ? was : this.inoOf(path);
+        const ino = writable2 ? this.openedIno(fd) ?? this.inoOf(path) : void 0;
+        if (truncate) this.fs.touched?.(path, ino);
         this.table.set(fd, { type: "kernel", kind: "file", nonblock: false, append, path, ino });
         if (append) this.publishFlags(fd, { nonblock: false, append });
         this.bump();
@@ -6618,9 +6661,9 @@ var init_wasi_host = __esm({
         this.unnamed.add(e);
         let path;
         try {
-          const st = this.kernelStat(fd);
+          const st = this.o.kernel.call({ op: "fd-vfs-stat", fd, identity: true });
           path = st.orphan ? void 0 : st.path;
-          if (path !== void 0) e.ino = this.o.fs.stat(path).ino;
+          if (path !== void 0) e.ino = st.ino ?? this.o.fs.stat(path).ino;
         } catch {
           return;
         }