@ai-ecoverse/slicc-kernel 1.57.0 → 1.58.0

package/dist/process-worker.js

@@ -600,11 +600,54 @@ function toMs(v) {
   if (v === void 0 || v === null) return void 0;
   return v instanceof Date ? v.getTime() : v;
 }
+function linkedStates(bridgeOf) {
+  const opens = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  const idOf2 = (st) => st?.ino === void 0 || (st.nlink ?? 1) < 2 ? void 0 : `${st.dev}:${st.ino}`;
+  function know(s, id) {
+    s.id = id;
+    if (!byId.has(id)) byId.set(id, s);
+  }
+  function opening(node, on) {
+    const s = node.live;
+    if (!on) {
+      opens.delete(s);
+      if (s.id !== void 0 && byId.get(s.id) === s) byId.delete(s.id);
+      s.id = void 0;
+      return;
+    }
+    opens.set(s, node);
+    const id = idOf2(s.stat);
+    if (id !== void 0) know(s, id);
+  }
+  function sharedWith(node) {
+    const st = node.live.stat;
+    if (st?.ino === void 0) return void 0;
+    const id = `${st.dev}:${st.ino}`;
+    if (!byId.has(id) && idOf2(st) !== void 0) {
+      for (const [s2, other] of opens) {
+        if (s2.id !== void 0 || s2.orphan) continue;
+        let st2;
+        try {
+          st2 = bridgeOf(other).lstat(liveNodePath(other));
+        } catch {
+        }
+        const known = idOf2(st2);
+        if (known !== void 0) know(s2, known);
+      }
+    }
+    const s = byId.get(id);
+    return s && s !== node.live && !stale(s) ? s : void 0;
+  }
+  const holder = (node) => opens.get(node.live) ?? node;
+  return { opening, sharedWith, know, idOf: idOf2, holder };
+}
 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);
   function markDirty(node) {
     node.live.dirty = true;
     dirty.add(node);
@@ -612,7 +655,7 @@ function createHelpers(Fs, ops) {
   function flushDirty() {
     for (const node of [...dirty]) {
       const s = node.live;
-      if (!s.dirty || s.orphan) {
+      if (!s.dirty || stale(s)) {
         dirty.delete(node);
         continue;
       }
@@ -654,7 +697,7 @@ function createHelpers(Fs, ops) {
       return { ...node.live.stat, size };
     }
     if (!node.live.stat) {
-      const st = call2(() => bridgeOf(node).lstat(liveNodePath(node)));
+      const st = call2(() => bridgeOf(node).lstat(liveNodePath(linked.holder(node))));
       node.live.stat = st;
       node.mode = modeFromStat(st);
     }
@@ -667,7 +710,7 @@ function createHelpers(Fs, ops) {
   function ensureLoaded(node) {
     const s = node.live;
     if (s.loaded) return;
-    const bytes = call2(() => fileIo(node).readFile(liveNodePath(node)));
+    const bytes = call2(() => fileIo(node).readFile(liveNodePath(linked.holder(node))));
     s.data = bytes;
     s.len = bytes.length;
     s.loaded = true;
@@ -676,7 +719,7 @@ function createHelpers(Fs, ops) {
     const s = node.live;
     if (s.ranged || !s.ranges) return s.ranged;
     const bridge = bridgeOf(node);
-    const path = () => liveNodePath(node);
+    const path = () => liveNodePath(linked.holder(node));
     const file = () => fileIo(node);
     const io = {
       pread: (_, at, n, version) => file().pread(path(), at, n, version),
@@ -698,11 +741,11 @@ function createHelpers(Fs, ops) {
   }
   function flushNode(node) {
     const s = node.live;
-    if (!s.dirty || s.orphan || !(s.data || s.ranged)) return;
+    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(node), bytes, true));
+      call2(() => fileIo(node).writeFile(liveNodePath(linked.holder(node)), bytes, true));
     }
     s.dirty = false;
     s.stat = void 0;
@@ -750,6 +793,7 @@ function createHelpers(Fs, ops) {
     Fs,
     bridgeOf,
     handled,
+    linked,
     call: call2,
     metadataCall,
     makeNode,
@@ -764,6 +808,33 @@ function createHelpers(Fs, ops) {
     truncate
   };
 }
+function freshStat(h, node) {
+  const { statOf } = h;
+  const st = statOf(node);
+  if (!st.linkable) return st;
+  node.live.stat = void 0;
+  return statOf(node);
+}
+function orphaned(h, node, st) {
+  const { bridgeOf } = h;
+  const s = node.live;
+  const nlink = st.nlink ?? 1;
+  let kept = false;
+  try {
+    kept = nlink > 1 && s.handle !== void 0 && bridgeOf(node).kept?.(s.handle) === true;
+  } catch {
+  }
+  if (nlink > 1 && !kept && h.linked.holder(node) !== node) {
+    s.stat = void 0;
+    return;
+  }
+  s.orphan = true;
+  if (!kept) return;
+  s.kept = true;
+  s.stat = { ...st, nlink: nlink - 1 };
+  const id = h.linked.idOf(st);
+  if (id !== void 0) h.linked.know(s, id);
+}
 function createNodeOps(h) {
   const { Fs, bridgeOf, call: call2, metadataCall, makeNode, statOf, childPath, flushNode, truncate } = h;
   const { ensureLoaded } = h;
@@ -794,7 +865,7 @@ function createNodeOps(h) {
         dev: st.dev ?? 1,
         ino: st.ino ?? inodeOf(liveNodePath(node)),
         mode: node.mode,
-        nlink: 1,
+        nlink: st.nlink ?? 1,
         uid: owned ? st.uid ?? 0 : 0,
         gid: owned ? st.gid ?? 0 : 0,
         rdev: 0,
@@ -889,14 +960,14 @@ function createNodeOps(h) {
         if (node && node.live?.openCount > 0 && Fs.isFile(node.mode)) open = node;
       } catch {
       }
+      const st = open && freshStat(h, open);
       if (open) {
-        statOf(open);
         const ranged = h.rangedOf(open);
         if (ranged) ranged.pin();
         else ensureLoaded(open);
       }
       call2(() => bridgeOf(parent).unlink(childPath(parent, name2)));
-      if (open) open.live.orphan = true;
+      if (open && st) orphaned(h, open, st);
     },
     rmdir(parent, name2) {
       parent.live.listed = void 0;
@@ -944,6 +1015,7 @@ function createStreamOps(h) {
     try {
       const handle = bridgeOf(node).hold?.(liveNodePath(node), on, true, s.handle);
       s.handle = on ? handle : void 0;
+      h.linked.opening(node, on);
       if (s.handle === void 0) h.handled.delete(node);
       else h.handled.add(node);
     } catch {
@@ -956,7 +1028,9 @@ function createStreamOps(h) {
       if (s.openCount === 0 && !s.orphan) {
         const bridge = bridgeOf(stream.node);
         s.ranges = !!(bridge.pread && bridge.pwrite && bridge.truncate && statOf(stream.node).ranged);
-        rangedOf(stream.node);
+        const shared = h.linked.sharedWith(stream.node);
+        if (shared) stream.node.live = shared;
+        else rangedOf(stream.node);
       }
       if ((stream.flags & 3) !== 0) {
         try {
@@ -1278,7 +1352,7 @@ function useLiveChown(Fs) {
     Fs.chown(target, uid, gid);
   };
 }
-var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END, EARLY_WHOLE_FILE;
+var S_IFDIR, S_IFREG, S_IFLNK, PERM_MASK, DEFAULT_DIR_PERM, UMASK, SEEK_CUR, SEEK_END, EARLY_WHOLE_FILE, stale;
 var init_live_vfs_fs = __esm({
   "src/realm/live-vfs-fs.ts"() {
     "use strict";
@@ -1294,6 +1368,7 @@ var init_live_vfs_fs = __esm({
     SEEK_CUR = 1;
     SEEK_END = 2;
     EARLY_WHOLE_FILE = 64 * 1024;
+    stale = (s) => !!s.orphan && !s.kept;
   }
 });
 
@@ -1369,10 +1444,12 @@ function parseSyncFsStat(json) {
     ...typeof s.atimeMs === "number" ? { atimeMs: s.atimeMs } : {},
     ...typeof s.ctimeMs === "number" ? { ctimeMs: s.ctimeMs } : {},
     ...typeof s.ino === "number" ? { ino: s.ino } : {},
+    ...typeof s.nlink === "number" ? { nlink: s.nlink } : {},
     ...typeof s.dev === "number" ? { dev: s.dev } : {},
     ...s.readonly === true ? { readonly: true } : {},
     ...typeof s.maxFile === "number" ? { maxFile: s.maxFile } : {},
     ...s.ranged === true ? { ranged: true } : {},
+    ...s.linkable === true ? { linkable: true } : {},
     ...typeof s.version === "string" ? { version: s.version } : {},
     ...typeof s.uid === "number" ? { uid: s.uid } : {},
     ...typeof s.gid === "number" ? { gid: s.gid } : {}
@@ -1393,6 +1470,7 @@ var init_sync_fs_wire = __esm({
       "mkdir",
       "rm",
       "rename",
+      "link",
       "unlink",
       "rmdir",
       "symlink",
@@ -1639,6 +1717,9 @@ function createSyncFsSabBridge(transport, opts = {}) {
     rename: (from, to) => {
       run({ op: "rename", path: from, arg2: to }, from);
     },
+    link: (from, to, follow2) => {
+      run({ op: "link", path: from, arg2: to, ...follow2 ? { mode: 1 } : {} }, from);
+    },
     unlink: (path) => {
       run({ op: "unlink", path }, path);
     },
@@ -4555,10 +4636,26 @@ function pathInode(path) {
   }
   return h;
 }
-function cachingBridge(bridge, now = () => performance.now()) {
-  const stats = /* @__PURE__ */ new Map();
-  const lstats = /* @__PURE__ */ new Map();
+function inoKey(st) {
+  return "ino" in st && typeof st.ino === "number" ? st.ino % 4294967296 | 0 : 0;
+}
+function pathHash(path) {
+  let h = 2166136261;
+  for (let i = 0; i < path.length; i++) h = Math.imul(h ^ path.charCodeAt(i), 16777619);
+  return h === 0 ? 1 : h;
+}
+function index(map, key, path) {
+  const paths = map.get(key) ?? /* @__PURE__ */ new Set();
+  paths.add(path);
+  map.set(key, paths);
+}
+function cachingBridge(bridge, now = () => performance.now(), shared) {
+  const blind = shared !== void 0 && shared.length * 4 < SHARED_IDS_BYTES;
+  const cache = new StatCache(blind ? void 0 : shared);
+  const { stats, lstats } = cache;
   const cached = (map, path, get) => {
+    if (blind) return get();
+    cache.fresh();
     let hit = map.get(path);
     if (hit === void 0 || "until" in hit && hit.until <= now()) {
       try {
@@ -4566,22 +4663,29 @@ function cachingBridge(bridge, now = () => performance.now()) {
       } catch (e) {
         hit = { error: e, until: now() + MISS_TTL_MS };
       }
-      map.set(path, hit);
+      cache.put(map, path, hit);
     }
     if ("until" in hit) throw hit.error;
     return hit;
   };
-  const invalidate = () => {
-    stats.clear();
-    lstats.clear();
+  const invalidate = () => cache.mutated([]);
+  const touched = (path, ino) => cache.changed(path, ino);
+  const mutating = (op, ...paths) => {
+    try {
+      return op();
+    } finally {
+      cache.mutated(paths);
+    }
   };
-  const mutating = (op) => {
+  const rewriting = (p, op, ...also) => {
+    const ino = cache.inoOf(p, () => bridge.stat(p));
     try {
       return op();
     } finally {
-      invalidate();
+      cache.mutated([p, ...also], ino);
     }
   };
+  const entry = (p) => [p, p.slice(0, p.lastIndexOf("/")) || "/"];
   return {
     readFile: (p) => bridge.readFile(p),
     readdir: (p) => bridge.readdir(p),
@@ -4589,9 +4693,9 @@ function cachingBridge(bridge, now = () => performance.now()) {
       const list = bridge.readdirStat(p);
       const base = p === "/" ? "" : p;
       for (const [name2, st] of list) {
-        if (!st) continue;
-        lstats.set(`${base}/${name2}`, st);
-        if (!st.isSymbolicLink) stats.set(`${base}/${name2}`, st);
+        if (!st || blind) continue;
+        cache.put(lstats, `${base}/${name2}`, st);
+        if (!st.isSymbolicLink) cache.put(stats, `${base}/${name2}`, st);
       }
       return list;
     },
@@ -4606,40 +4710,42 @@ function cachingBridge(bridge, now = () => performance.now()) {
         return false;
       }
     },
-    writeFile: (p, bytes, open) => mutating(() => bridge.writeFile(p, bytes, open)),
-    mkdir: (p) => mutating(() => bridge.mkdir(p)),
+    writeFile: (p, bytes, open) => rewriting(p, () => bridge.writeFile(p, bytes, open), ...entry(p).slice(1)),
+    mkdir: (p) => mutating(() => bridge.mkdir(p), ...entry(p)),
     rm: (p) => mutating(() => bridge.rm(p)),
     rename: (from, to) => mutating(() => bridge.rename(from, to)),
+    link: (from, to, follow2) => mutating(() => bridge.link(from, to, follow2)),
     unlink: (p) => mutating(() => bridge.unlink(p)),
     rmdir: (p) => mutating(() => bridge.rmdir(p)),
-    symlink: (target, link) => mutating(() => bridge.symlink(target, link)),
-    chmod: (p, mode) => mutating(() => bridge.chmod(p, mode)),
-    utimes: (p, a, m) => mutating(() => bridge.utimes(p, a, m)),
-    lutimes: (p, a, m) => mutating(() => bridge.lutimes(p, a, m)),
+    symlink: (target, link) => mutating(() => bridge.symlink(target, link), ...entry(link)),
+    chmod: (p, mode) => rewriting(p, () => bridge.chmod(p, mode)),
+    utimes: (p, a, m) => rewriting(p, () => bridge.utimes(p, a, m)),
+    lutimes: (p, a, m) => mutating(() => bridge.lutimes(p, a, m), p),
     ...bridge.hold ? { hold: bridge.hold.bind(bridge) } : {},
     ...bridge.kept ? { kept: bridge.kept.bind(bridge) } : {},
-    ...bridge.pinned ? { pinned: (handle) => pinnedIo2(bridge, handle, mutating) } : {},
-    ...bridge.create ? { create: (p) => mutating(() => bridge.create?.(p)) } : {},
+    ...bridge.pinned ? { pinned: (handle) => pinnedIo2(bridge, handle, rewriting) } : {},
+    ...bridge.create ? { create: (p) => mutating(() => bridge.create?.(p), ...entry(p)) } : {},
     ...bridge.pread && bridge.pwrite && bridge.truncate ? {
       pread: bridge.pread.bind(bridge),
-      pwrite: (p, at, bytes, transfer) => mutating(() => bridge.pwrite?.(p, at, bytes, transfer)),
-      truncate: (p, size) => mutating(() => bridge.truncate?.(p, size))
+      pwrite: (p, at, bytes, transfer) => rewriting(p, () => bridge.pwrite?.(p, at, bytes, transfer)),
+      truncate: (p, size) => rewriting(p, () => bridge.truncate?.(p, size))
     } : {},
-    invalidate
+    invalidate,
+    touched
   };
 }
-function pinnedIo2(bridge, handle, mutating) {
+function pinnedIo2(bridge, handle, rewriting) {
   const io = bridge.pinned(handle);
   const { pread, pwrite, truncate } = io;
   return {
     readFile: (p) => io.readFile(p),
-    writeFile: (p, bytes, open) => mutating(() => io.writeFile(p, bytes, open)),
+    writeFile: (p, bytes, open) => rewriting(p, () => io.writeFile(p, bytes, open)),
     pread: (p, at, n, version) => pread(p, at, n, version),
-    pwrite: (p, at, bytes, transfer) => mutating(() => pwrite(p, at, bytes, transfer)),
-    truncate: (p, size) => mutating(() => truncate(p, size))
+    pwrite: (p, at, bytes, transfer) => rewriting(p, () => pwrite(p, at, bytes, transfer)),
+    truncate: (p, size) => rewriting(p, () => truncate(p, size))
   };
 }
-var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS;
+var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS, FS_GEN, RING, RING_SIZE, SLOT, SHARED_IDS_BYTES, StatCache;
 var init_wasi_files = __esm({
   "src/process/wasi/wasi-files.ts"() {
     "use strict";
@@ -4829,6 +4935,110 @@ var init_wasi_files = __esm({
     };
     MAX_LINKS = 40;
     MISS_TTL_MS = 20;
+    FS_GEN = 4;
+    RING = 8;
+    RING_SIZE = 64;
+    SLOT = 3;
+    SHARED_IDS_BYTES = (RING + RING_SIZE * SLOT) * 4;
+    StatCache = class {
+      stats = /* @__PURE__ */ new Map();
+      lstats = /* @__PURE__ */ new Map();
+      byHash = /* @__PURE__ */ new Map();
+      byIno = /* @__PURE__ */ new Map();
+      shared;
+      seen;
+      constructor(shared) {
+        this.shared = shared;
+        this.seen = shared ? Atomics.load(shared, FS_GEN) : 0;
+      }
+      put(map, path, entry) {
+        map.set(path, entry);
+        if (!this.shared) return;
+        index(this.byHash, pathHash(path), path);
+        const ino = inoKey(entry);
+        if (ino !== 0) index(this.byIno, ino, path);
+      }
+      fresh() {
+        if (!this.shared) return;
+        const now = Atomics.load(this.shared, FS_GEN);
+        if (now === this.seen) return;
+        this.replay(now);
+        this.seen = now;
+      }
+      changed(path, ino = 0) {
+        const key = ino % 4294967296 | 0;
+        if (this.shared) {
+          const g = this.publish(this.shared, path === void 0 ? 0 : pathHash(path), key);
+          this.replay(g - 1);
+          this.seen = g;
+          if (path === void 0) this.clear();
+          else this.drop(pathHash(path), key);
+        }
+        if (path === void 0) return;
+        this.stats.delete(path);
+        this.lstats.delete(path);
+      }
+      mutated(paths, ino = 0) {
+        this.clear();
+        if (!this.shared) return;
+        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);
+        }
+      }
+      inoOf(path, look) {
+        if (!this.shared) return 0;
+        this.fresh();
+        const hit = this.stats.get(path);
+        if (hit && "ino" in hit && typeof hit.ino === "number") return hit.ino;
+        try {
+          return look().ino ?? 0;
+        } catch {
+          return 0;
+        }
+      }
+      publish(shared, hash, ino) {
+        const g = Atomics.add(shared, FS_GEN, 1) + 1;
+        const at = RING + g % RING_SIZE * SLOT;
+        Atomics.store(shared, at, 0);
+        Atomics.store(shared, at + 1, hash);
+        Atomics.store(shared, at + 2, ino);
+        Atomics.store(shared, at, g);
+        return g;
+      }
+      replay(upTo) {
+        const shared = this.shared;
+        const missed = [];
+        for (let g = this.seen + 1; g <= upTo && upTo - this.seen <= RING_SIZE; g++) {
+          const at = RING + g % RING_SIZE * SLOT;
+          const tag = Atomics.load(shared, at);
+          const hash = Atomics.load(shared, at + 1);
+          const ino = Atomics.load(shared, at + 2);
+          if (tag !== g || hash === 0 || Atomics.load(shared, at) !== g) break;
+          missed.push([hash, ino]);
+        }
+        if (missed.length < upTo - this.seen) this.clear();
+        else for (const [hash, ino] of missed) this.drop(hash, ino);
+      }
+      drop(hash, ino) {
+        const paths = [
+          ...this.byHash.get(hash) ?? [],
+          ...ino === 0 ? [] : this.byIno.get(ino) ?? []
+        ];
+        for (const path of paths) {
+          this.stats.delete(path);
+          this.lstats.delete(path);
+        }
+        this.byHash.delete(hash);
+        if (ino !== 0) this.byIno.delete(ino);
+      }
+      clear() {
+        this.stats.clear();
+        this.lstats.clear();
+        this.byHash.clear();
+        this.byIno.clear();
+      }
+    };
   }
 });
 
@@ -4923,6 +5133,8 @@ var init_wasi_fds = __esm({
     WasiFds = class {
       table = /* @__PURE__ */ new Map();
       buffers = /* @__PURE__ */ new Map();
+      byId = /* @__PURE__ */ new Map();
+      ids = /* @__PURE__ */ new Map();
       kernel;
       fs;
       constructor(kernel, fs) {
@@ -5161,11 +5373,18 @@ var init_wasi_fds = __esm({
             handed.add(e.file.buffer);
             promoted.set(e.file, fd);
           }
-          this.table.set(fd, { type: "kernel", kind: "file", nonblock: false, append: e.file.append });
+          this.table.set(fd, {
+            type: "kernel",
+            kind: "file",
+            nonblock: false,
+            append: e.file.append,
+            path: e.file.path,
+            ino: this.inoOf(e.file.path)
+          });
         }
         for (const file of promoted.keys()) {
           if (--file.buffer.opens <= 0) {
-            this.buffers.delete(file.path);
+            this.forget(file.buffer);
             this.letGo(file.buffer);
           }
         }
@@ -5236,9 +5455,48 @@ var init_wasi_fds = __esm({
         const { buffer } = e.file;
         buffer.flush();
         if (--buffer.opens > 0) return;
-        if (this.buffers.get(buffer.path) === buffer) this.buffers.delete(buffer.path);
+        this.forget(buffer);
         this.letGo(buffer);
       }
+      forget(buffer) {
+        for (const [p, b] of [...this.buffers]) if (b === buffer) this.buffers.delete(p);
+        const id = this.ids.get(buffer);
+        if (id !== void 0 && this.byId.get(id) === buffer) this.byId.delete(id);
+        this.ids.delete(buffer);
+      }
+      know(buffer, id) {
+        if (this.ids.has(buffer)) return;
+        this.ids.set(buffer, id);
+        if (!this.byId.has(id)) this.byId.set(id, buffer);
+      }
+      identity(st) {
+        if (!st || st.ino === void 0 || (st.nlink ?? 1) < 2) return void 0;
+        return `${st.dev ?? 0}:${st.ino}`;
+      }
+      sharing(path, st) {
+        if (st?.ino === void 0) return void 0;
+        const id = `${st.dev ?? 0}:${st.ino}`;
+        if (!this.byId.has(id) && this.identity(st) !== void 0) this.learn();
+        const buffer = this.byId.get(id);
+        if (!buffer) return void 0;
+        this.buffers.set(path, buffer);
+        return buffer;
+      }
+      learn() {
+        for (const [p, buffer] of this.buffers) {
+          if (this.ids.has(buffer) || buffer.isOrphan()) continue;
+          const known = this.identity(this.statOrMissing(p));
+          if (known !== void 0) this.know(buffer, known);
+        }
+      }
+      linked(from, to) {
+        const buffer = this.buffers.get(from);
+        if (!buffer || buffer.isOrphan()) return;
+        const id = this.identity(this.statOrMissing(to));
+        if (id === void 0) return;
+        this.know(buffer, id);
+        if (!this.buffers.has(to)) this.buffers.set(to, buffer);
+      }
       letGo(buffer) {
         this.fs.hold?.(buffer.path, false, true, buffer.handle);
       }
@@ -5264,32 +5522,63 @@ var init_wasi_fds = __esm({
         for (const [p, buffer] of this.buffers) if (within(p, path)) buffer.flush();
         if (this.shared) this.kernel.call({ op: "fd-path-flush", path });
       }
-      unlinking(path) {
-        this.buffers.get(path)?.keep();
+      holdsUnder(path) {
+        for (const p of this.buffers.keys()) if (within(p, path)) return true;
+        return false;
+      }
+      unlinking(path, linked) {
+        const buffer = this.buffers.get(path);
+        if (buffer && this.survives(buffer, linked)) buffer.flush();
+        else buffer?.keep();
         if (this.shared) this.kernel.call({ op: "fd-path-unlinking", path });
       }
-      unlinked(path) {
+      unlinked(path, linked) {
         if (this.shared) this.kernel.call({ op: "fd-path-unlinked", path });
         const buffer = this.buffers.get(path);
         if (!buffer) return;
-        buffer.orphan();
+        this.detach(buffer, linked);
         this.buffers.delete(path);
       }
-      renamed(from, to) {
+      inoOf(path) {
+        try {
+          return this.fs.stat(path).ino;
+        } catch {
+          return void 0;
+        }
+      }
+      survives(buffer, linked) {
+        return linked !== void 0 && buffer.handle !== void 0;
+      }
+      detach(buffer, linked) {
+        if (this.survives(buffer, linked)) {
+          const id = this.identity(linked);
+          if (id !== void 0) this.know(buffer, id);
+          return;
+        }
+        buffer.orphan();
+        this.forget(buffer);
+      }
+      renamed(from, to, replacedLinked) {
         if (from === to) return;
         if (this.shared) 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);
+          }
+        }
         const moved = [];
         for (const [p, buffer] of this.buffers) {
           if (within(p, from)) moved.push([p, buffer]);
           else if (within(p, to)) {
-            buffer.orphan();
+            this.detach(buffer, replacedLinked);
             this.buffers.delete(p);
           }
         }
+        for (const [p] of moved) this.buffers.delete(p);
         for (const [p, buffer] of moved) {
-          this.buffers.delete(p);
-          buffer.path = to + p.slice(from.length);
-          this.buffers.set(buffer.path, buffer);
+          const next2 = to + p.slice(from.length);
+          if (buffer.path === p) buffer.path = next2;
+          this.buffers.set(next2, buffer);
         }
       }
       resolve(dirfd, path) {
@@ -5332,6 +5621,7 @@ var init_wasi_fds = __esm({
           this.buffers.delete(path);
           buffer = void 0;
         }
+        buffer ??= this.sharing(path, existing);
         if (buffer) {
           if (oflags & OFLAGS.TRUNC) buffer.truncate(0);
         } else {
@@ -5345,6 +5635,8 @@ var init_wasi_fds = __esm({
           buffer = new FileBuffer(io, path, empty, st.maxFile, ranged, st.version);
           buffer.handle = handle;
           this.buffers.set(path, buffer);
+          const id = this.identity(st);
+          if (id !== void 0) this.know(buffer, id);
         }
         buffer.opens++;
         return new LocalFile(buffer, readable2, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
@@ -5356,7 +5648,10 @@ 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 } : {});
-        this.table.set(fd, { type: "kernel", kind: "file", nonblock: false, append });
+        const was = existing && this.inoOf(path);
+        if (truncate) this.fs.touched?.(path, was);
+        const ino = existing ? was : this.inoOf(path);
+        this.table.set(fd, { type: "kernel", kind: "file", nonblock: false, append, path, ino });
         if (append) this.publishFlags(fd, { nonblock: false, append });
         this.bump();
         return fd;
@@ -5675,6 +5970,16 @@ var init_wasi_termios = __esm({
 });
 
 // src/process/wasi/wasi-host.ts
+function linkedOf(st) {
+  return (st.nlink ?? 1) > 1 ? st : void 0;
+}
+function linkedElsewhere(fs, path) {
+  try {
+    return linkedOf(fs.lstat(path));
+  } catch {
+    return void 0;
+  }
+}
 function filetypeOf(s) {
   if (!s) return FILETYPE.UNKNOWN;
   if (s.isSymbolicLink) return FILETYPE.SYMBOLIC_LINK;
@@ -5686,6 +5991,7 @@ function filestatOf(path, s) {
     filetype: filetypeOf(s),
     size: BigInt(s.size),
     ino: s.ino !== void 0 ? BigInt(s.ino) : pathInode(path),
+    ...s.nlink !== void 0 ? { nlink: BigInt(s.nlink) } : {},
     mtimeNs: BigInt(Math.round(s.mtimeMs ?? 0)) * NS_PER_MS
   };
 }
@@ -5736,6 +6042,7 @@ var WasiExit, IDS, NS_PER_MS, AT_SYMLINK_NOFOLLOW2, S_IFIFO, DEFAULT_UMASK, MONO
 var init_wasi_host = __esm({
   "src/process/wasi/wasi-host.ts"() {
     "use strict";
+    init_physical_path();
     init_cred();
     init_wasi_abi();
     init_wasi_fds();
@@ -6045,17 +6352,20 @@ var init_wasi_host = __esm({
           path_remove_directory: (dirfd, p, l) => void o.fs.rmdir(at(dirfd, p, l)),
           path_unlink_file: (dirfd, p, l) => {
             const path = at(dirfd, p, l);
-            if (o.fs.lstat(path).isDirectory) throw new WasiError("EISDIR");
-            fds.unlinking(path);
+            const st = o.fs.lstat(path);
+            if (st.isDirectory) throw new WasiError("EISDIR");
+            const linked = linkedOf(st);
+            fds.unlinking(path, linked);
             o.fs.unlink(path);
-            fds.unlinked(path);
+            fds.unlinked(path, linked);
           },
           path_rename: (fd, p, l, fd2, p2, l2) => {
             const from = at(fd, p, l);
             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);
-            fds.renamed(from, to);
+            fds.renamed(from, to, replaced);
           },
           path_symlink: (tp, tl, dirfd, p, l) => void o.fs.symlink(mem.string(tp, tl), at(dirfd, p, l)),
           path_readlink: (dirfd, p, l, buf, len, used) => {
@@ -6064,7 +6374,17 @@ var init_wasi_host = __esm({
             mem.bytes(buf, n).set(target.subarray(0, n));
             mem.view().setUint32(used, n, true);
           },
-          path_link: () => E.NOTSUP
+          path_link: (fd, lookup, p, l, fd2, p2, l2) => {
+            const from = at(fd, p, l);
+            const to = at(fd2, p2, l2);
+            const follow2 = (lookup & LOOKUP_SYMLINK_FOLLOW) !== 0;
+            const source = follow2 ? physicalPath(o.fs, from) : from;
+            fds.flushPath(from);
+            if (source !== from) fds.flushPath(source);
+            o.fs.link(from, to, follow2);
+            fds.linked(from, to);
+            if (source !== from) fds.linked(source, to);
+          }
         };
       }
       socket(fd) {
@@ -6150,11 +6470,29 @@ var init_wasi_host = __esm({
             if (!kernel.sys.pread) throw new WasiError("ESPIPE");
             return kernel.sys.pread(fd, Math.min(max, MAX_READ), at);
           },
-          pwrite: (body, at) => kernel.call({ op: "fd-pwrite", fd, offset: at, body }),
+          pwrite: (body, at) => this.changed(fd, e, kernel.call({ op: "fd-pwrite", fd, offset: at, body })),
           size: () => this.kernelStat(fd).size,
-          truncate: (size) => void kernel.call({ op: "fd-resize", fd, size })
+          truncate: (size) => this.changed(fd, e, void kernel.call({ op: "fd-resize", fd, size }))
         };
       }
+      unnamed = /* @__PURE__ */ new WeakSet();
+      changed(fd, e, result) {
+        if (e.path === void 0 && !this.unnamed.has(e)) this.learnPath(fd, e);
+        this.o.fs.touched?.(e.path, e.ino);
+        return result;
+      }
+      learnPath(fd, e) {
+        this.unnamed.add(e);
+        let path;
+        try {
+          const st = this.kernelStat(fd);
+          path = st.orphan ? void 0 : st.path;
+          if (path !== void 0) e.ino = this.o.fs.stat(path).ino;
+        } catch {
+          return;
+        }
+        e.path = path;
+      }
       kernelStat(fd) {
         return this.o.kernel.call({ op: "fd-vfs-stat", fd });
       }
@@ -6163,7 +6501,8 @@ var init_wasi_host = __esm({
         const e = this.fds.get(fd);
         if (e.type === "kernel") {
           try {
-            return this.o.kernel.sys.write(fd, data, { nonblock: e.nonblock });
+            const n = this.o.kernel.sys.write(fd, data, { nonblock: e.nonblock });
+            return this.fds.kind(fd, e) === "file" ? this.changed(fd, e, n) : n;
           } catch (err) {
             const broken = err.code === "EPIPE";
             if (broken && this.fds.kind(fd, e) !== "socket") throw new WasiExit(SIGPIPE_EXIT);
@@ -6249,7 +6588,7 @@ var init_wasi_host = __esm({
         v.setBigUint64(ptr, 1n, true);
         v.setBigUint64(ptr + 8, f.ino, true);
         v.setUint8(ptr + 16, f.filetype);
-        v.setBigUint64(ptr + 24, 1n, true);
+        v.setBigUint64(ptr + 24, f.nlink ?? 1n, true);
         v.setBigUint64(ptr + 32, f.size, true);
         v.setBigUint64(ptr + 40, f.mtimeNs, true);
         v.setBigUint64(ptr + 48, f.mtimeNs, true);
@@ -6360,6 +6699,7 @@ var init_wasi_threads = __esm({
   "src/process/wasi/wasi-threads.ts"() {
     "use strict";
     init_protocol();
+    init_wasi_files();
     LAST_TID = 0;
     RUNNING = 1;
     MAIN_TID = 1;
@@ -6382,7 +6722,7 @@ var init_wasi_threads = __esm({
         this.memory = memory;
         this.cap = cap;
         this.tid = tid;
-        this.ids = new Int32Array(ids ?? new SharedArrayBuffer(16));
+        this.ids = new Int32Array(ids ?? new SharedArrayBuffer(SHARED_IDS_BYTES));
         if (!ids) Atomics.store(this.ids, LAST_TID, MAIN_TID);
       }
       spawn(arg) {
@@ -7052,6 +7392,13 @@ function procfsBridge(fs, tree) {
       () => fs.rename(from, to)
     ),
     symlink: (target, link) => readOnly([[link, false]], () => fs.symlink(target, link)),
+    link: (from, to, follow2) => readOnly(
+      [
+        [from, follow2 === true],
+        [to, false]
+      ],
+      () => fs.link(from, to, follow2)
+    ),
     hold: (p, held, open, handle) => {
       if (handle !== void 0 && snapshots.delete(handle)) return void 0;
       if (!held) return fs.hold?.(p, held, open, handle);
@@ -7824,8 +8171,8 @@ function readExports(r, s) {
   for (let i = r.u32(); i > 0; i--) {
     const name2 = r.name();
     const kind = r.byte();
-    const index2 = r.u32();
-    if (kind === 0) s.info.exports[name2] = index2;
+    const index3 = r.u32();
+    if (kind === 0) s.info.exports[name2] = index3;
   }
 }
 function readElems(r, s) {
@@ -8128,15 +8475,15 @@ var init_wasix_linker = __esm({
         return out;
       }
       allocateClosure() {
-        const index2 = this.indices.allocate(this.table.length);
-        growTable(this.table, index2 + 1);
-        this.live.add(index2);
-        return index2;
+        const index3 = this.indices.allocate(this.table.length);
+        growTable(this.table, index3 + 1);
+        this.live.add(index3);
+        return index3;
       }
-      freeClosure(index2) {
-        this.indices?.free(index2);
-        this.live.delete(index2);
-        this.table.set(index2, null);
+      freeClosure(index3) {
+        this.indices?.free(index3);
+        this.live.delete(index3);
+        this.table.set(index3, null);
       }
       live = /* @__PURE__ */ new Set();
       prepareClosure(record) {
@@ -8369,12 +8716,12 @@ var init_wasix_linker = __esm({
         this.indexTable();
         const known = this.slots.get(fn);
         if (known !== void 0) return known;
-        const index2 = this.reserve(1);
-        growTable(this.table, index2 + 1);
-        this.table.set(index2, fn);
-        this.slots.set(fn, index2);
-        this.publisher?.({ kind: "slot", index: index2, handle, name: name2 });
-        return index2;
+        const index3 = this.reserve(1);
+        growTable(this.table, index3 + 1);
+        this.table.set(index3, fn);
+        this.slots.set(fn, index3);
+        this.publisher?.({ kind: "slot", index: index3, handle, name: name2 });
+        return index3;
       }
       allocate(size, alignment) {
         if (size === 0) return 0;
@@ -8659,11 +9006,11 @@ var init_wasix_sockets = __esm({
 });
 
 // src/process/wasi/wasix-host.ts
-function futexWait(view, index2, expected, ms, interrupted) {
+function futexWait(view, index3, expected, ms, interrupted) {
   const deadline = performance.now() + ms;
   for (; ; ) {
     const slice = interrupted ? Math.min(FUTEX_SLICE_MS, ms) : ms;
-    if (Atomics.wait(view, index2, expected, slice) !== "timed-out") return true;
+    if (Atomics.wait(view, index3, expected, slice) !== "timed-out") return true;
     if (interrupted?.()) return true;
     ms = deadline - performance.now();
     if (ms <= 0) return false;
@@ -8792,21 +9139,21 @@ var init_wasix_host = __esm({
             if (!this.linker) throw new WasiError("ENOTSUP");
             this.mem.view().setUint32(out, this.linker.allocateClosure(), true);
           },
-          closure_prepare: (backing, index2, argTypes, argCount, resultTypes, resultCount, userData) => {
+          closure_prepare: (backing, index3, argTypes, argCount, resultTypes, resultCount, userData) => {
             if (!this.linker) throw new WasiError("ENOTSUP");
             const params = valueTypes(this.mem.bytes(argTypes, argCount));
             const results = valueTypes(this.mem.bytes(resultTypes, resultCount));
             if (!params || !results) throw new WasiError("EINVAL");
             try {
-              this.linker.prepareClosure({ index: index2, backing, userData, params, results });
+              this.linker.prepareClosure({ index: index3, backing, userData, params, results });
             } catch (e) {
               if (e instanceof DlError) throw new WasiError("EINVAL");
               throw e;
             }
           },
-          closure_free: (index2) => {
+          closure_free: (index3) => {
             if (!this.linker) throw new WasiError("ENOTSUP");
-            this.linker.freeClosure(index2);
+            this.linker.freeClosure(index3);
           },
           call_dynamic: (...a) => void callDynamic(
             { mem: this.mem, table: () => this.table, types: this.types },
@@ -9111,10 +9458,10 @@ function parseFunctionNames(payload) {
     if (end > payload.length) throw new RangeError("truncated name section");
     if (id === 1) {
       for (let count = leb(); count > 0; count--) {
-        const index2 = leb();
+        const index3 = leb();
         const length = leb();
         if (at + length > end) throw new RangeError("truncated name section");
-        names.set(index2, decoder3.decode(payload.subarray(at, at + length)));
+        names.set(index3, decoder3.decode(payload.subarray(at, at + length)));
         at += length;
       }
     }
@@ -9138,7 +9485,7 @@ function nameFrame(line, module, name2) {
 }
 function sidecarNames(read2, path) {
   let names;
-  return (index2) => {
+  return (index3) => {
     if (!names) {
       try {
         names = parseFunctionNames(read2(path));
@@ -9146,7 +9493,7 @@ function sidecarNames(read2, path) {
         names = /* @__PURE__ */ new Map();
       }
     }
-    return names.get(index2);
+    return names.get(index3);
   };
 }
 var UNNAMED_FRAME, WASM_MODULE;
@@ -9507,7 +9854,7 @@ async function runWasiProcess(init, port2) {
     parent: () => identify(transport, init).ppid,
     kernel: { sys: traced(stats, "kernel", sys), call: call2 },
     fs: procfsBridge(
-      cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport))),
+      cachingBridge(traced(stats, "fs", createSyncFsSabBridge(transport)), void 0, threads?.ids),
       procTree(call2, id.pid)
     ),
     ...descriptors(init, fork, threads)
@@ -9600,7 +9947,10 @@ async function runWasiThread(init, port2) {
     ppid: id.ppid,
     parent: () => identify(transport, init).ppid,
     kernel: { sys, call: call2 },
-    fs: procfsBridge(cachingBridge(createSyncFsSabBridge(transport)), procTree(call2, id.pid)),
+    fs: procfsBridge(
+      cachingBridge(createSyncFsSabBridge(transport), void 0, threads.ids),
+      procTree(call2, id.pid)
+    ),
     shared: threads.ids
   });
   const program = await programImports(init.program, host, transport, thread.tid);
@@ -9712,13 +10062,13 @@ var init_wasi_runtime = __esm({
           },
           unlock: () => this.call({ op: "dl-unlock", owner: this.owner }),
           allocate: (floor) => {
-            const index2 = this.call({ op: "dl-closure", floor });
+            const index3 = this.call({ op: "dl-closure", floor });
             this.catchUp();
             this.bump();
-            return index2;
+            return index3;
           },
-          free: (index2) => {
-            this.call({ op: "dl-closure-free", index: index2 });
+          free: (index3) => {
+            this.call({ op: "dl-closure-free", index: index3 });
             this.bump();
           }
         };
@@ -9771,8 +10121,8 @@ var init_wasi_runtime = __esm({
 });
 
 // src/process/js/async-sab.ts
-async function changed(header, index2, seen, waitAsync = defaultWaitAsync) {
-  const waited = waitAsync(header, index2, seen);
+async function changed(header, index3, seen, waitAsync = defaultWaitAsync) {
+  const waited = waitAsync(header, index3, seen);
   if (waited.async) await waited.value;
 }
 function createAsyncSabTransport(sab, port2, waitAsync = defaultWaitAsync) {
@@ -10534,7 +10884,7 @@ function openRequest(abs, o) {
     ...o.truncate ? { truncate: true } : {}
   };
 }
-function index(n, what) {
+function index2(n, what) {
   if (!Number.isSafeInteger(n) || n < 0) throw new JsCallError("EINVAL", what);
 }
 var CHUNK2, MAX_IO, O_WRONLY6, O_RDWR6, O_APPEND3;
@@ -10707,7 +11057,7 @@ function syncOps(kernel, shared) {
     return got;
   };
   const read2 = (fd, max = CHUNK2) => {
-    index(max, "read");
+    index2(max, "read");
     const emulated = readDevice(info(fd), max, shared.random);
     if (emulated) return emulated;
     const r = kernel.blocking({ op: "fd-read", fd, max: Math.min(max, MAX_IO) });
@@ -10785,8 +11135,8 @@ function syncFile(kernel, fd, path, append, forget) {
       return kernel.json({ op: "fd-vfs-stat", fd }).size;
     },
     read(position, length) {
-      index(position, "read");
-      index(length, "read");
+      index2(position, "read");
+      index2(length, "read");
       const parts = [];
       let got = 0;
       do {
@@ -10801,7 +11151,7 @@ function syncFile(kernel, fd, path, append, forget) {
       return joined(parts, got);
     },
     write(position, data) {
-      index(position, "write");
+      index2(position, "write");
       let at = 0;
       do {
         live();
@@ -10815,7 +11165,7 @@ function syncFile(kernel, fd, path, append, forget) {
     },
     truncate(size) {
       live();
-      index(size, "truncate");
+      index2(size, "truncate");
       kernel.call({ op: "fd-resize", fd, size });
     },
     sync() {
@@ -10846,6 +11196,7 @@ function syncPathOps(kernel, resolve, statOf, open) {
     rm: (path) => void kernel.call({ op: "rm", path: resolve(path) }),
     unlink: (path) => void kernel.call({ op: "unlink", path: resolve(path) }),
     rename: (from, to) => void kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
+    link: (from, to) => void kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
     symlink: (target, path) => void kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
     readlink: (path) => String(kernel.json({ op: "readlink", path: resolve(path) })),
     readFile(path) {
@@ -11211,7 +11562,7 @@ function createContext(o) {
     return got;
   };
   const read2 = async (fd, max = CHUNK2, signal) => {
-    index(max, "read");
+    index2(max, "read");
     const emulated = readDevice(await info(fd), max, random);
     if (emulated) return emulated;
     return readPipe(kernel, fd, Math.min(max, MAX_IO), signal);
@@ -11358,8 +11709,8 @@ function fileHandle(kernel, fd, path, append, forget) {
       return s.size;
     },
     async read(position, length) {
-      index(position, "read");
-      index(length, "read");
+      index2(position, "read");
+      index2(length, "read");
       const parts = [];
       let got = 0;
       do {
@@ -11374,7 +11725,7 @@ function fileHandle(kernel, fd, path, append, forget) {
       return joined(parts, got);
     },
     async write(position, data) {
-      index(position, "write");
+      index2(position, "write");
       let at = 0;
       do {
         live();
@@ -11388,7 +11739,7 @@ function fileHandle(kernel, fd, path, append, forget) {
     },
     async truncate(size) {
       live();
-      index(size, "truncate");
+      index2(size, "truncate");
       await kernel.call({ op: "fd-resize", fd, size });
     },
     async sync() {
@@ -11442,6 +11793,7 @@ function pathOps(kernel, resolve, statOf, open) {
     rm: async (path) => void await kernel.call({ op: "rm", path: resolve(path) }),
     unlink: async (path) => void await kernel.call({ op: "unlink", path: resolve(path) }),
     rename: async (from, to) => void await kernel.call({ op: "rename", path: resolve(from), arg2: resolve(to) }),
+    link: async (from, to) => void await kernel.call({ op: "link", path: resolve(from), arg2: resolve(to) }),
     symlink: async (target, path) => void await kernel.call({ op: "symlink", path: resolve(path), arg2: target }),
     readlink: async (path) => String(await kernel.json({ op: "readlink", path: resolve(path) })),
     async readFile(path) {