@ai-ecoverse/slicc-kernel 1.143.5 → 1.143.6

package/dist/process-worker.js

@@ -561,7 +561,7 @@ function normal(path) {
   }
   return `/${parts.join("/")}`;
 }
-var GEN, RING, RING_SIZE, SLOT, SHARED_TTL_MS, DIRTY, FOREIGN, CHANGES_BYTES, ChangeView;
+var GEN, RING, RING_SIZE, SLOT, SHARED_TTL_MS, RENAME_WAIT_MS, DIRTY, FOREIGN, RENAMES, CHANGES_BYTES, ChangeView;
 var init_changes = __esm({
   "src/fs/changes.ts"() {
     "use strict";
@@ -570,9 +570,11 @@ var init_changes = __esm({
     RING_SIZE = 4096;
     SLOT = 2;
     SHARED_TTL_MS = 100;
+    RENAME_WAIT_MS = 100;
     DIRTY = RING + RING_SIZE * SLOT;
     FOREIGN = DIRTY + 1;
-    CHANGES_BYTES = (FOREIGN + 1) * 4;
+    RENAMES = FOREIGN + 1;
+    CHANGES_BYTES = (RENAMES + 1) * 4;
     ChangeView = class {
       view;
       constructor(sab) {
@@ -587,6 +589,13 @@ var init_changes = __esm({
       foreign() {
         return this.view.length > FOREIGN && Atomics.load(this.view, FOREIGN) === 1;
       }
+      renames() {
+        return this.view.length > RENAMES ? Atomics.load(this.view, RENAMES) : 0;
+      }
+      awaitRename(seen, ms) {
+        if (this.view.length > RENAMES) Atomics.wait(this.view, RENAMES, seen, ms);
+        return this.renames();
+      }
       changedSince(seen, path) {
         const now = Atomics.load(this.view, GEN);
         const distance = now - seen >>> 0;
@@ -1163,7 +1172,8 @@ var init_sync_fs_wire = __esm({
       "truncate",
       "chown",
       "lchown",
-      "access"
+      "access",
+      "renames"
     ];
     HOLD_READ = 4;
     HOLD_WRITE = 8;
@@ -1180,7 +1190,8 @@ var init_sync_fs_wire = __esm({
       "readlink",
       "statfs",
       "kept",
-      "access"
+      "access",
+      "renames"
     ]);
   }
 });
@@ -1372,7 +1383,9 @@ function createSyncFsSabBridge(transport, opts = {}) {
       run({ op: "rm", path }, path);
     },
     rename: (from, to) => {
-      run({ op: "rename", path: from, arg2: to }, from);
+      const r = run({ op: "rename", path: from, arg2: to }, from);
+      const seq = r.ok && r.kind === "json" ? r.json.seq : void 0;
+      return typeof seq === "number" ? seq : void 0;
     },
     link: (from, to, follow3) => {
       run({ op: "link", path: from, arg2: to, ...follow3 ? { mode: 1 } : {} }, from);
@@ -1453,7 +1466,11 @@ function createSyncFsSabBridge(transport, opts = {}) {
       run({ op: "hold", path, mode, ...handle !== void 0 ? { handle } : {} }, path);
       return void 0;
     },
-    statfs: (path = "/") => parseSyncFsUsage(json2({ op: "statfs", path }, path))
+    statfs: (path = "/") => parseSyncFsUsage(json2({ op: "statfs", path }, path)),
+    renames: (since, held2) => json2(
+      { op: "renames", path: "/", offset: since, arg2: JSON.stringify(held2) },
+      "/"
+    )
   };
 }
 var UNCOUNTED_OPS, calls, looks, SPIN_MS, SPIN_STRIDE, SPIN_STRIDES, SPIN_CORES, spinning, SPIN_CAP_MS;
@@ -1650,12 +1667,130 @@ function freshState(stat) {
   const base = { len: 0, loaded: false, dirty: false, openCount: 0 };
   return stat ? { stat, statAt: syncCallCount(), filledAt: performance.now(), seenAt: syncEpoch(), ...base } : base;
 }
+function inCache(Fs, node) {
+  const table = Fs.nameTable;
+  const parent = node.parent;
+  const hash = Fs.hashName?.(parent.id ?? 0, node.name);
+  if (!table || hash === void 0) return true;
+  let at = table[hash];
+  while (at) {
+    if (at === node) return true;
+    at = at.name_next;
+  }
+  return false;
+}
+function heldUnder(held2, from) {
+  let moving = held2;
+  while (moving && moving !== moving.mount.root && liveNodePath(moving) !== from) {
+    moving = moving.parent;
+  }
+  return moving && moving !== moving.mount.root && liveNodePath(moving) === from ? moving : void 0;
+}
+function relinked(Fs, moving, to) {
+  const slash = to.lastIndexOf("/");
+  let dir;
+  try {
+    dir = Fs.lookupPath?.(slash <= 0 ? "/" : to.slice(0, slash)).node;
+  } catch {
+  }
+  if (!dir || dir.mount !== moving.mount) return;
+  const name2 = to.slice(slash + 1);
+  try {
+    const existing = Fs.lookupNode?.(dir, name2);
+    if (existing && existing !== moving) Fs.hashRemoveNode?.(existing);
+  } catch {
+  }
+  moving.parent.live.listed = void 0;
+  dir.live.listed = void 0;
+  Fs.hashRemoveNode?.(moving);
+  moving.name = name2;
+  moving.parent = dir;
+  Fs.hashAddNode?.(moving);
+  moving.live.stat = void 0;
+}
+function renameFollower(Fs, bridgeOf, call2) {
+  const open = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
+  const follow3 = (node, missing2 = false) => {
+    const bridge = bridgeOf(node);
+    const view = bridge.changes;
+    const since = seen.get(bridge);
+    let now = view?.renames() ?? 0;
+    if (missing2 && view && now === since) now = view.awaitRename(now, RENAME_WAIT_MS);
+    const ask = bridge.renames?.bind(bridge);
+    if (since === void 0 || now === since || !ask) return false;
+    const held2 = [...open].filter((n) => !n.live.orphan && bridgeOf(n) === bridge);
+    if (held2.length === 0) {
+      seen.set(bridge, now);
+      return false;
+    }
+    const reply = call2(
+      () => ask(
+        since,
+        held2.map((n) => liveNodePath(n))
+      )
+    );
+    seen.set(bridge, reply.now);
+    for (const [from, to] of reply.renames) {
+      for (const n of held2) {
+        const moving = heldUnder(n, from);
+        if (moving && inCache(Fs, moving)) relinked(Fs, moving, to);
+      }
+    }
+    return reply.renames.length > 0;
+  };
+  return {
+    open,
+    follow: follow3,
+    track(node, on) {
+      if (!on) {
+        open.delete(node);
+        return;
+      }
+      follow3(node);
+      open.add(node);
+    },
+    watchRenames(bridge) {
+      if (!seen.has(bridge)) seen.set(bridge, bridge.changes?.renames() ?? 0);
+    },
+    ownRename(bridge, seq) {
+      const since = seen.get(bridge);
+      if (seq !== void 0 && since !== void 0 && seq === (since + 1 | 0))
+        seen.set(bridge, seq);
+    }
+  };
+}
+function followingOnce(write2, follow3) {
+  try {
+    write2();
+  } catch (err) {
+    if (err.errno !== wasiErrno("ENOENT") || !follow3()) throw err;
+    write2();
+  }
+}
+function renameThrough(h, node, from, to) {
+  const seq = h.call(() => h.bridgeOf(node).rename(from, to));
+  h.ownRename(h.bridgeOf(node), typeof seq === "number" ? seq : void 0);
+}
+function heldStream(h, stream, change) {
+  const s = stream.node.live;
+  if ((stream.flags & 3) === 0 || s.orphan) return;
+  const before = s.writers ?? 0;
+  s.writers = Math.max(0, before + change);
+  if (before === 0 !== (s.writers === 0)) {
+    try {
+      h.bridgeOf(stream.node).hold?.(liveNodePath(stream.node), s.writers > 0);
+    } catch {
+    }
+  }
+}
 function createHelpers(Fs, ops) {
   const bridgeOf = (node) => node.mount.opts.bridge;
   const fileIo = (node) => pinnedIo(bridgeOf(node), node.live.handle);
   const dirty = /* @__PURE__ */ new Set();
   const handled = /* @__PURE__ */ new Set();
   const linked = linkedStates(bridgeOf);
+  const renames = renameFollower(Fs, bridgeOf, (fn) => call2(fn));
   function markDirty(node) {
     node.live.dirty = true;
     dirty.add(node);
@@ -1748,11 +1883,9 @@ function createHelpers(Fs, ops) {
   function flushNode(node) {
     const s = node.live;
     if (!s.dirty || stale(s) || !(s.data || s.ranged)) return;
-    if (s.ranged) call2(() => s.ranged?.flush());
-    else {
-      const bytes = s.data.slice(0, s.len);
-      call2(() => fileIo(node).writeFile(liveNodePath(linked.holder(node)), bytes, true));
-    }
+    const whole = () => s.data.slice(0, s.len);
+    const write2 = () => s.ranged ? call2(() => s.ranged?.flush()) : call2(() => fileIo(node).writeFile(liveNodePath(linked.holder(node)), whole(), true));
+    followingOnce(write2, () => renames.follow(node, true));
     s.dirty = false;
     s.stat = void 0;
   }
@@ -1800,6 +1933,7 @@ function createHelpers(Fs, ops) {
     bridgeOf,
     handled,
     linked,
+    ...renames,
     call: call2,
     metadataCall,
     makeNode,
@@ -1959,7 +2093,7 @@ function createNodeOps(h) {
       const from = liveNodePath(oldNode);
       const to = childPath(newDir, newName);
       flushNode(oldNode);
-      call2(() => bridgeOf(oldNode).rename(from, to));
+      renameThrough(h, oldNode, from, to);
       try {
         const existing = Fs.lookupNode?.(newDir, newName);
         if (existing && existing !== oldNode) Fs.hashRemoveNode?.(existing);
@@ -2054,21 +2188,11 @@ function dropOpen(s) {
 }
 function createStreamOps(h) {
   const { Fs, statOf, ensureLoaded, ensureCapacity, flushNode, bridgeOf, rangedOf } = h;
-  const held2 = (stream, change) => {
-    const s = stream.node.live;
-    if ((stream.flags & 3) === 0 || s.orphan) return;
-    const before = s.writers ?? 0;
-    s.writers = Math.max(0, before + change);
-    if (before === 0 !== (s.writers === 0)) {
-      try {
-        bridgeOf(stream.node).hold?.(liveNodePath(stream.node), s.writers > 0);
-      } catch {
-      }
-    }
-  };
+  const held2 = (stream, change) => heldStream(h, stream, change);
   const opened2 = (node, on, want = 0) => {
     const s = node.live;
     try {
+      h.track(node, on);
       const handle = holdLive(bridgeOf(node), node, on, want);
       s.handle = on ? handle : void 0;
       h.linked.opening(node, on);
@@ -2164,6 +2288,7 @@ function createStreamOps(h) {
       if (!Fs.isFile(node.mode)) return;
       const s = node.live;
       if (!dropOpen(s)) return;
+      h.follow(node);
       if (s.openCount > 0) {
         held2(stream, -1);
         return;
@@ -2177,12 +2302,14 @@ function createStreamOps(h) {
         s.len = 0;
         s.loaded = false;
         held2(stream, -1);
+        h.track(node, false);
         if (s.handle !== void 0) opened2(node, false);
       }
     },
     read(stream, buffer, offset, length, position) {
       const node = stream.node;
       if (Fs.isDir(node.mode)) throw new Fs.ErrnoError(wasiErrno("EISDIR"));
+      h.follow(node);
       const ranged = rangedOf(node);
       if (ranged) {
         const out2 = new Uint8Array(buffer.buffer, buffer.byteOffset + offset, Math.max(0, length));
@@ -2200,6 +2327,7 @@ function createStreamOps(h) {
       const node = stream.node;
       if (Fs.isDir(node.mode)) throw new Fs.ErrnoError(wasiErrno("EISDIR"));
       if (length <= 0) return 0;
+      h.follow(node);
       const s = node.live;
       const end = position + length;
       if (s.maxFile !== void 0 && end > s.maxFile) throw new Fs.ErrnoError(wasiErrno("EFBIG"));
@@ -2231,6 +2359,7 @@ function createStreamOps(h) {
       return pos;
     },
     fsync(stream) {
+      h.follow(stream.node);
       flushNode(stream.node);
     }
   };
@@ -2265,6 +2394,7 @@ function createLiveVfsPlugin(Fs) {
     flushDirty: () => h.flushDirty(),
     mount(mount) {
       const st = h.call(() => mount.opts.bridge.stat(mount.opts.root));
+      h.watchRenames(mount.opts.bridge);
       if (!st.isDirectory) throw new Fs.ErrnoError(wasiErrno("ENOTDIR"));
       const root = h.makeNode(null, "/", st);
       root.mode = modeFromStat(st, mount.opts.bridge.owners === true);
@@ -2783,7 +2913,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.143.5" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.143.6" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -7059,6 +7189,7 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
   const entry = (p) => [p, p.slice(0, p.lastIndexOf("/")) || "/"];
   return {
     ...bridge.changes ? { changes: bridge.changes } : {},
+    ...bridge.renames ? { renames: bridge.renames.bind(bridge) } : {},
     readFile: (p) => bridge.readFile(p),
     readdir: (p) => bridge.readdir(p),
     readdirStat: (p) => {
@@ -7175,6 +7306,7 @@ var init_wasi_files = __esm({
       seen = 0;
       maxFile;
       handle;
+      moved;
       constructor(fs, path, empty, maxFile, size, version, watch) {
         this.fs = fs;
         this.where = path;
@@ -7183,7 +7315,11 @@ var init_wasi_files = __esm({
         this.watch = watch;
         this.seen = watch?.seen ?? watch?.view.now() ?? 0;
         if (size !== void 0 && pread && pwrite && truncate) {
-          const io = { pread: pread.bind(fs), pwrite: pwrite.bind(fs), truncate: truncate.bind(fs) };
+          const io = {
+            pread: (_, ...rest2) => this.retried(() => pread.call(fs, this.where, ...rest2)),
+            pwrite: (_, ...rest2) => this.retried(() => pwrite.call(fs, this.where, ...rest2)),
+            truncate: (_, size2) => this.retried(() => truncate.call(fs, this.where, size2))
+          };
           this.ranged = new RangedFile(io, path, size, version, watch);
           if (empty) this.truncate(0);
         } else if (empty) {
@@ -7195,6 +7331,14 @@ var init_wasi_files = __esm({
       get path() {
         return this.where;
       }
+      retried(op) {
+        try {
+          return op();
+        } catch (err) {
+          if (err.code !== "ENOENT" || !this.moved?.(true)) throw err;
+          return op();
+        }
+      }
       set path(path) {
         this.where = path;
         if (this.ranged) this.ranged.path = path;
@@ -7218,7 +7362,7 @@ var init_wasi_files = __esm({
         }
         if (!this.data) {
           this.seen = view?.now() ?? 0;
-          this.data = this.fs.readFile(this.path);
+          this.data = this.retried(() => this.fs.readFile(this.path));
           this.length = this.data.length;
         }
         return this.data;
@@ -7259,8 +7403,9 @@ var init_wasi_files = __esm({
       append(bytes) {
         const { append } = this.fs;
         if (!append || this.orphaned) return void 0;
+        this.moved?.(false);
         this.flush();
-        const end = append.call(this.fs, this.path, bytes);
+        const end = this.retried(() => append.call(this.fs, this.path, bytes));
         if (!this.ranged) {
           this.data = void 0;
           this.length = 0;
@@ -7308,11 +7453,17 @@ var init_wasi_files = __esm({
       }
       flush() {
         if (this.orphaned || !this.dirty) return;
+        this.moved?.(false);
         if (this.ranged) this.ranged.flush();
         else if (!this.data) return;
-        else if (this.whole || !this.fs.pwrite)
-          this.fs.writeFile(this.path, this.data.slice(0, this.length), true);
-        else this.fs.pwrite(this.path, this.from, this.data.slice(this.from, this.to), true);
+        else if (this.whole || !this.fs.pwrite) {
+          const whole = this.data.slice(0, this.length);
+          this.retried(() => this.fs.writeFile(this.path, whole, true));
+        } else {
+          const { pwrite } = this.fs;
+          const run = this.data.slice(this.from, this.to);
+          this.retried(() => pwrite.call(this.fs, this.path, this.from, run, true));
+        }
         this.dirty = false;
         this.whole = false;
         this.from = Infinity;
@@ -8700,6 +8851,7 @@ var SYNTHETIC_DIRS2, O_NONBLOCK2, O_WRONLY5, O_RDWR5, O_APPEND3, SEALED_PATH2, C
 var init_wasi_fds = __esm({
   "src/process/wasi/wasi-fds.ts"() {
     "use strict";
+    init_changes();
     init_ranged();
     init_fd_table();
     init_sync_fs_wire();
@@ -8720,9 +8872,29 @@ var init_wasi_fds = __esm({
       ids = /* @__PURE__ */ new Map();
       kernel;
       fs;
+      renamesSeen;
       constructor(kernel, fs) {
         this.kernel = kernel;
         this.fs = fs;
+        this.renamesSeen = fs.changes?.renames() ?? 0;
+      }
+      ownRename(seq) {
+        if (seq !== void 0 && seq === (this.renamesSeen + 1 | 0)) this.renamesSeen = seq;
+      }
+      followRenames(missing2 = false) {
+        const view = this.fs.changes;
+        let now = view?.renames() ?? 0;
+        if (missing2 && view && now === this.renamesSeen) now = view.awaitRename(now, RENAME_WAIT_MS);
+        if (now === this.renamesSeen || !this.fs.renames) return false;
+        const held2 = [...this.buffers].filter(([, b]) => !b.isOrphan()).map(([p]) => p);
+        if (held2.length === 0) {
+          this.renamesSeen = now;
+          return false;
+        }
+        const { now: seen, renames } = this.fs.renames(this.renamesSeen, held2);
+        this.renamesSeen = seen;
+        for (const [from, to] of renames) this.renamed(from, to, void 0, true);
+        return renames.length > 0;
       }
       setup(cwd, inherited, root = false) {
         for (const fd of [0, 1, 2]) this.table.set(fd, this.stdioEntry(fd));
@@ -8922,6 +9094,7 @@ var init_wasi_fds = __esm({
       get(fd) {
         const e = this.find(fd);
         if (!e) throw new WasiError("EBADF");
+        if (e.type === "file") this.followRenames();
         return e;
       }
       preopen(fd) {
@@ -9242,9 +9415,9 @@ var init_wasi_fds = __esm({
         buffer.orphan();
         this.forget(buffer);
       }
-      renamed(from, to, replacedLinked) {
+      renamed(from, to, replacedLinked, foreign = false) {
         if (from === to) return;
-        if (this.shared) this.kernel.call({ op: "fd-path-renamed", from, to });
+        if (this.shared && !foreign) this.kernel.call({ op: "fd-path-renamed", from, to });
         for (const e of this.table.values()) {
           if (e.type === "kernel" && e.path !== void 0 && within(e.path, from)) {
             e.path = to + e.path.slice(from.length);
@@ -9252,6 +9425,7 @@ var init_wasi_fds = __esm({
         }
         const moved = [];
         for (const [p, buffer] of this.buffers) {
+          if (foreign && buffer.isOrphan()) continue;
           if (within(p, from)) moved.push([p, buffer]);
           else if (within(p, to)) {
             this.detach(buffer, replacedLinked);
@@ -9393,6 +9567,7 @@ var init_wasi_fds = __esm({
       }
       file(path, existing, oflags, rights, fdflags, mode, created = false) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
+        this.followRenames();
         let buffer = created ? void 0 : this.buffers.get(path);
         if (buffer?.handle !== void 0 && this.fs.kept?.(buffer.handle)) {
           this.buffers.delete(path);
@@ -9440,6 +9615,7 @@ var init_wasi_fds = __esm({
           st
         );
         const buffer = new FileBuffer(io, path, empty, st.maxFile, ranged, st.version, watch);
+        buffer.moved = (missing2) => this.followRenames(missing2);
         buffer.handle = handle;
         this.buffers.set(path, buffer);
         const id = this.identity(st);
@@ -11197,8 +11373,9 @@ var init_wasi_host = __esm({
             const to = at(fd2, p2, l2);
             fds.flushPath(from);
             const replaced = fds.holdsUnder(to) ? linkedElsewhere(o.fs, to) : void 0;
-            o.fs.rename(from, to);
+            const seq = o.fs.rename(from, to);
             fds.renamed(from, to, replaced);
+            fds.ownRename(typeof seq === "number" ? seq : void 0);
           },
           path_symlink: (tp, tl, dirfd, p, l) => {
             const path = at(dirfd, p, l);