@ai-ecoverse/slicc-kernel 1.57.1 → 1.58.1

package/dist/kernel-worker.js

@@ -188,6 +188,9 @@ async function lutimesOf(fs, path, atime, mtime) {
   if ((await fs.lstat(path)).isSymbolicLink) throw fsError("EOPNOTSUPP", path);
   return fs.utimes(path, atime, mtime);
 }
+function mayLink(fs, path) {
+  return fs.links?.(path) ?? true;
+}
 function fsError(code, path) {
   return Object.assign(new Error(`${code}: ${path}`), { code });
 }
@@ -791,12 +794,12 @@ var OpfsFs = class {
     const base = dir === "/" ? "" : dir;
     const metas = await this.meta.get(children2.map(([name2]) => `${base}/${name2}`));
     const handed2 = this.owners ? await this.handedTo(dir) : void 0;
-    const owned = (stat, entry) => handed2 ? { ...stat, ...ownOf(entry) ?? handed2 } : stat;
+    const owned2 = (stat, entry) => handed2 ? { ...stat, ...ownOf(entry) ?? handed2 } : stat;
     return Promise.all(
       children2.map(async ([name2, child], i) => {
-        if (!isHandle(child)) return [name2, owned(this.linkStat(child), child)];
+        if (!isHandle(child)) return [name2, owned2(this.linkStat(child), child)];
         const stat = await this.statOf(`${base}/${name2}`, child, metas[i]).catch(() => null);
-        return [name2, stat && owned(stat, metas[i])];
+        return [name2, stat && owned2(stat, metas[i])];
       })
     );
   }
@@ -855,6 +858,12 @@ var OpfsFs = class {
     await this.meta.remove([found.path]);
     this.touch(parentOf2(found.path));
   }
+  links() {
+    return false;
+  }
+  async link(from) {
+    throw fsError("EPERM", `${from}: this file system has no hard links`);
+  }
   async rename(from, to) {
     if (from === to) return;
     const source = await this.locate(from, false);
@@ -5814,6 +5823,8 @@ function withCommandDirs(fs, names, userDir = async () => void 0) {
       }
     },
     writeFile: (path, content, owner) => fs.writeFile(path, content, owner),
+    link: (from, to, follow2) => fs.link(from, to, follow2),
+    links: (path) => mayLink(fs, path),
     async exists(path) {
       return await fs.exists(path) || await linked(path) !== void 0;
     },
@@ -5952,6 +5963,8 @@ var UnlinkedKeeper = class {
   gate = new PathGate();
   queue = Promise.resolve();
   count = 0;
+  links = /* @__PURE__ */ new Map();
+  linked = /* @__PURE__ */ new Map();
   constructor(fs, holders, rootOf, options = {}) {
     const { locks, owner } = options;
     this.fs = fs;
@@ -5971,8 +5984,15 @@ var UnlinkedKeeper = class {
   wrap(fs = this.fs) {
     const keeper = this;
     const visible = (names) => names.filter((name2) => name2 !== UNLINKED_DIR);
+    const counted = (st) => {
+      const hidden = keeper.links.get(`${st.dev ?? 0}:${st.ino}`) ?? 0;
+      return hidden === 0 || st.nlink === void 0 ? st : { ...st, nlink: Math.max(0, st.nlink - hidden) };
+    };
     return {
       ...fs,
+      links: (path) => mayLink(fs, path),
+      stat: async (path) => counted(await fs.stat(path)),
+      lstat: async (path) => counted(await fs.lstat(path)),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
         const pinned = await keeper.pin(target);
@@ -5986,7 +6006,7 @@ var UnlinkedKeeper = class {
         await keeper.settle(pinned, () => fs.rename(from, to));
       },
       readdir: async (path) => visible(await fs.readdir(path)),
-      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR)
+      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted(st)])
     };
   }
   async settle(pinned, op) {
@@ -6036,6 +6056,7 @@ var UnlinkedKeeper = class {
           for (const holder of held.get(path)) holder.unkeep(path, file);
           await this.serial(async () => {
             await Promise.allSettled([this.fs.rename(file.hidden, path)]);
+            this.unlinkedName(file.hidden);
             await this.tidy(parentOf3(file.hidden));
           });
         }
@@ -6058,6 +6079,7 @@ var UnlinkedKeeper = class {
       try {
         await this.fs.mkdir(dir, { recursive: true });
         await this.fs.rename(path, hidden);
+        await this.linkedName(hidden);
         return hidden;
       } catch {
         await this.tidy(dir);
@@ -6074,8 +6096,25 @@ var UnlinkedKeeper = class {
       return;
     }
     await this.fs.rm(hidden).catch(() => void 0);
+    this.unlinkedName(hidden);
     await this.tidy(parentOf3(hidden));
   }
+  async linkedName(hidden) {
+    if (!mayLink(this.fs, hidden)) return;
+    const st = await this.fs.lstat(hidden).catch(() => void 0);
+    if (!st || (st.nlink ?? 1) < 2) return;
+    const id2 = `${st.dev ?? 0}:${st.ino}`;
+    this.linked.set(hidden, id2);
+    this.links.set(id2, (this.links.get(id2) ?? 0) + 1);
+  }
+  unlinkedName(hidden) {
+    const id2 = this.linked.get(hidden);
+    if (id2 === void 0) return;
+    this.linked.delete(hidden);
+    const left = (this.links.get(id2) ?? 1) - 1;
+    if (left > 0) this.links.set(id2, left);
+    else this.links.delete(id2);
+  }
   async tidy(dir) {
     const left = await this.fs.readdir(dir).catch(() => [UNLINKED_DIR]);
     if (left.length === 0) await this.fs.rm(dir, { recursive: true }).catch(() => void 0);
@@ -6169,6 +6208,10 @@ var FsWatchers = class {
       },
       rm: after(fs.rm.bind(fs), (path) => [path]),
       rename: after(fs.rename.bind(fs), (from, to) => [from, to]),
+      link: after(
+        (from, to, follow2) => fs.link(from, to, follow2),
+        (_from, to) => [to]
+      ),
       symlink: after(fs.symlink.bind(fs), (_target, path) => [path]),
       chmod: after(fs.chmod.bind(fs), (path) => [path]),
       ...fs.chown ? { chown: after(fs.chown.bind(fs), (path) => [path]) } : {},
@@ -6382,6 +6425,62 @@ var ChildTable = class {
   }
 };
 
+// src/fs/walk.ts
+var MAX_LINKS4 = 40;
+function parentOf5(path) {
+  return path.slice(0, path.lastIndexOf("/")) || "/";
+}
+async function mustBeDir(fs, path) {
+  if (!fs.lstat) return;
+  const st = await fs.lstat(path);
+  if (st.isDirectory !== true) throw fsError("ENOTDIR", path);
+}
+async function linkOf(fs, path) {
+  return fs.readlink?.(path).catch(() => void 0);
+}
+async function realDir(fs, dir, budget = { hops: 0 }) {
+  const queue = dir.split("/").filter(Boolean);
+  let at = "/";
+  while (queue.length > 0) {
+    const part = queue.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      at = parentOf5(at);
+      continue;
+    }
+    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
+    const link2 = await linkOf(fs, next2);
+    if (link2 === void 0) {
+      if (queue.find((p) => p !== ".") === "..") await mustBeDir(fs, next2);
+      at = next2;
+      continue;
+    }
+    if (budget.hops >= MAX_LINKS4) throw fsError("ELOOP", dir);
+    budget.hops++;
+    queue.unshift(...link2.split("/").filter(Boolean));
+    if (link2.startsWith("/")) at = "/";
+  }
+  return at;
+}
+function joinName(dir, name2) {
+  return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
+}
+async function realTarget(fs, path) {
+  const budget = { hops: 0 };
+  let dir = await realDir(fs, parentOf5(path), budget);
+  let name2 = path.slice(path.lastIndexOf("/") + 1);
+  for (; ; ) {
+    const link2 = await linkOf(fs, joinName(dir, name2));
+    if (link2 === void 0) break;
+    if (budget.hops >= MAX_LINKS4) throw fsError("ELOOP", path);
+    budget.hops++;
+    const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
+    dir = await realDir(fs, parentOf5(target), budget);
+    name2 = target.slice(target.lastIndexOf("/") + 1);
+  }
+  return joinName(dir, name2);
+}
+
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 1];
 function driverVersionError(theirs) {
@@ -6485,7 +6584,7 @@ var DriverConnection = class _DriverConnection {
 };
 
 // src/mount/mount-fs.ts
-var MAX_LINKS4 = 40;
+var MAX_LINKS5 = 40;
 var STALE_RETRIES = 3;
 var SETTLE_ROUNDS = 4;
 var DEFAULT_IO = 8 * 1024 * 1024;
@@ -6649,8 +6748,13 @@ var HeldPaths = class extends Map {
     return this.revoked.has(path);
   }
 };
-var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var readonly = (mount) => mount.caps.readonly === true || mount.options.ro !== void 0;
+function inodeless(mount, attr) {
+  if (attr.ino !== void 0) return false;
+  if (mount.caps.links) mount.caps = { ...mount.caps, links: false };
+  return true;
+}
 function statOf(attr, path, mount) {
   const mtime = new Date(attr.mtime);
   const fallback = attr.kind === "directory" ? 16877 : attr.kind === "symlink" ? 41471 : 33188;
@@ -6664,10 +6768,12 @@ function statOf(attr, path, mount) {
     atime: mtime,
     ctime: mtime,
     ino: attr.ino ?? inodeOf(path),
+    ...!inodeless(mount, attr) && attr.nlink !== void 0 ? { nlink: attr.nlink } : {},
     dev: mount.dev,
     ...readonly(mount) ? { readonly: true } : {},
     ...mount.maxFile > 0 ? { maxFile: mount.maxFile } : {},
     ...mount.caps.ranges ? { ranged: true } : {},
+    ...mount.caps.links ? { linkable: true } : {},
     ...attr.etag !== void 0 ? { version: attr.etag } : {}
   };
 }
@@ -6916,7 +7022,7 @@ var MountTable = class {
     mount.epoch++;
     for (const key of [...mount.attrs.keys()]) if (within4(key, path)) mount.attrs.delete(key);
     mount.lists.delete(path);
-    mount.lists.delete(parentOf5(path));
+    mount.lists.delete(parentOf6(path));
     for (const key of [...mount.lists.keys()]) if (within4(key, path)) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
@@ -6990,9 +7096,9 @@ var MountFs = class {
       throw err;
     }
     if (attr.kind !== "symlink") return real;
-    if (hops >= MAX_LINKS4) throw errnoError("ELOOP", path);
+    if (hops >= MAX_LINKS5) throw errnoError("ELOOP", path);
     const target = await found.mount.conn.call({ op: "readlink", path: found.rel });
-    return this.follow(this.base.resolvePath(parentOf5(real), target), hops + 1, create);
+    return this.follow(this.base.resolvePath(parentOf6(real), target), hops + 1, create);
   }
   async open(mount, rel2, write) {
     return await mount.conn.call({
@@ -7322,6 +7428,34 @@ var MountFs = class {
       this.table.forget(a.mount, normalizePath(to));
     }
   }
+  links(path) {
+    const found = this.at(path);
+    return found ? found.mount.caps.links === true : mayLink(this.base, path);
+  }
+  async named(path) {
+    const at = normalizePath(path);
+    return joinName(await realDir(this, parentOf6(at)), at.slice(at.lastIndexOf("/") + 1));
+  }
+  async link(source, target, follow2 = false) {
+    const from = follow2 ? await realTarget(this, normalizePath(source)) : await this.named(source);
+    const to = await this.named(target);
+    const a = this.at(from);
+    const b = this.at(to);
+    if (!a && !b) return this.base.link(from, to);
+    if (!a || !b || a.mount !== b.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
+    this.writable(a.mount, normalizePath(to));
+    if (a.mount.caps.links) await this.lstat(from);
+    if (!a.mount.caps.links) {
+      throw errnoError("EPERM", `${from}: this file system has no hard links`);
+    }
+    await this.table.commitUnder(from);
+    try {
+      await a.mount.conn.call({ op: "link", from: a.rel, to: b.rel });
+    } finally {
+      this.table.forget(a.mount, normalizePath(from));
+      this.table.forget(a.mount, normalizePath(to));
+    }
+  }
   async symlink(target, path, owner) {
     const found = this.at(path);
     if (!found) return this.base.symlink(target, path, owner);
@@ -7421,10 +7555,12 @@ function statJson(s) {
     atimeMs: s.atime.getTime(),
     ctimeMs: s.ctime.getTime(),
     ino: s.ino,
+    ...s.nlink !== void 0 ? { nlink: s.nlink } : {},
     ...s.dev !== void 0 ? { dev: s.dev } : {},
     ...s.readonly ? { readonly: true } : {},
     ...s.maxFile ? { maxFile: s.maxFile } : {},
     ...s.ranged ? { ranged: true } : {},
+    ...s.linkable ? { linkable: true } : {},
     ...s.version !== void 0 ? { version: s.version } : {},
     ...s.uid !== void 0 ? { uid: s.uid } : {},
     ...s.gid !== void 0 ? { gid: s.gid } : {}
@@ -7493,6 +7629,9 @@ async function run(entry, path, req) {
       entry.renamed?.(path, to);
       return done;
     }
+    case "link":
+      await fs.link(path, fs.resolvePath(cwd, req.arg2 ?? ""), req.mode === 1);
+      return done;
     case "unlink":
       if ((await fs.lstat(path)).isDirectory) throw syncError("EISDIR", path);
       await fs.rm(path);
@@ -7554,12 +7693,28 @@ async function ranged(fs, path, req) {
   return done;
 }
 var UNLINKED_OPS = /* @__PURE__ */ new Set(["read", "pread", "pwrite", "truncate"]);
-var OWN_OPS = /* @__PURE__ */ new Set(["rm", "unlink", "rmdir", "rename"]);
+var OWN_OPS = /* @__PURE__ */ new Set(["rm", "unlink", "rmdir", "rename", "link"]);
+var TWO_PATHS = /* @__PURE__ */ new Set(["rename", "link"]);
+var UNLINKING_OPS = /* @__PURE__ */ new Set(["rm", "unlink", "rename"]);
+async function linkedElsewhere(fs, path, from) {
+  if (!mayLink(fs, path)) return false;
+  const st = await fs.lstat(path).catch(() => void 0);
+  if (!st || (st.nlink ?? 1) < 2) return false;
+  const source = from === void 0 ? void 0 : await fs.lstat(from).catch(() => void 0);
+  return !(source && source.ino === st.ino && source.dev === st.dev);
+}
 async function keptOr(entry, path, handle) {
   if (handle !== void 0) return entry.keptFor?.(handle)?.hidden ?? path;
   const kept = entry.unlinked?.(path);
   return kept && !await entry.fs.exists(path) ? kept.hidden : path;
 }
+async function owned(entry, own, req, path, target) {
+  const source = target === path ? void 0 : path;
+  if (UNLINKING_OPS.has(req.op) && await linkedElsewhere(entry.fs, target, source)) {
+    return run(entry, path, req);
+  }
+  return own(target, () => run(entry, path, req));
+}
 async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
@@ -7583,8 +7738,8 @@ async function dispatchSyncFs(req) {
       return await (entry.gate ? entry.gate(path, serve) : serve());
     }
     if (!entry.own || !OWN_OPS.has(req.op)) return await run(entry, path, req);
-    const target = req.op === "rename" ? fs.resolvePath(cwd, req.arg2 ?? "") : path;
-    return await entry.own(target, () => run(entry, path, req));
+    const target = TWO_PATHS.has(req.op) ? fs.resolvePath(cwd, req.arg2 ?? "") : path;
+    return await owned(entry, entry.own, req, path, target);
   } catch (err) {
     return toErrno(err);
   }
@@ -9531,6 +9686,7 @@ var VfsNode = class {
   fs;
   path;
   orphaned;
+  id;
   constructor(fs, path, contents2, orphaned = false, dirty = false, pin) {
     this.fs = fs;
     this.pin = pin;
@@ -9700,6 +9856,7 @@ var VfsNode = class {
 var VfsNodes = class {
   byPath = /* @__PURE__ */ new Map();
   kept = /* @__PURE__ */ new Map();
+  byId = /* @__PURE__ */ new Map();
   keepsOnDisk = false;
   fs;
   entries = /* @__PURE__ */ new Map();
@@ -9719,7 +9876,7 @@ var VfsNodes = class {
     return run2;
   }
   async entryKey(path) {
-    const parent = parentOf6(path);
+    const parent = parentOf5(path);
     const dir = await this.real(parent, true, () => realDir(this.fs, parent));
     return joinName(dir, path.slice(path.lastIndexOf("/") + 1));
   }
@@ -9744,21 +9901,66 @@ var VfsNodes = class {
       await this.fs.writeFile(path, new Uint8Array(0), owner);
     });
   }
-  open(path, pin, writable = false) {
-    let node = this.byPath.get(path);
-    if (!node) {
-      node = new VfsNode(this.fs, path, void 0, false, false, pin);
-      this.byPath.set(path, node);
-    }
+  async identity(path) {
+    const st = await this.fs.stat?.(path).catch(() => void 0);
+    if (!st || st.ino === void 0 || (st.nlink ?? 1) < 2) return void 0;
+    return `${st.dev ?? 0}:${st.ino}`;
+  }
+  async identify(path) {
+    return this.byPath.has(path) || !mayLink(this.fs, path) ? void 0 : this.identity(path);
+  }
+  async linked(from, to) {
+    const node = this.byPath.get(from);
+    if (!node || node.orphaned) return;
+    const id2 = node.id ?? await this.identity(to);
+    if (id2 === void 0 || node.orphaned) return;
+    this.know(node, id2);
+    if (!this.byPath.has(to)) this.byPath.set(to, node);
+  }
+  know(node, id2) {
+    node.id = id2;
+    if (!this.byId.has(id2)) this.byId.set(id2, node);
+  }
+  namesOf(node) {
+    const out = [];
+    for (const [p, n] of this.byPath) if (n === node) out.push(p);
+    return out;
+  }
+  forget(node) {
+    for (const p of this.namesOf(node)) this.byPath.delete(p);
+    if (node.id !== void 0 && this.byId.get(node.id) === node) this.byId.delete(node.id);
+  }
+  orphan(node) {
+    node.orphaned = true;
+    this.forget(node);
+  }
+  dropName(path, node) {
+    const others = this.namesOf(node).filter((p) => p !== path);
+    if (others.length === 0) return false;
+    this.byPath.delete(path);
+    if (node.path === path) node.renamedTo(others[0]);
+    return true;
+  }
+  named(path, id2) {
+    const node = this.byPath.get(path) ?? (id2 === void 0 ? void 0 : this.byId.get(id2));
+    if (node && !this.byPath.has(path)) this.byPath.set(path, node);
+    return node;
+  }
+  create(path, id2, node) {
+    this.byPath.set(path, node);
+    if (id2 !== void 0) this.know(node, id2);
+    return node;
+  }
+  open(path, pin, writable = false, id2) {
+    const node = this.named(path, id2) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
     node.opens++;
     if (writable) node.writers++;
     return node;
   }
-  adopt(path, contents2, dirty, writable = false) {
-    let node = this.byPath.get(path);
+  adopt(path, contents2, dirty, writable = false, id2) {
+    let node = this.named(path, id2);
     if (!node) {
-      node = new VfsNode(this.fs, path, contents2, false, dirty);
-      this.byPath.set(path, node);
+      node = this.create(path, id2, new VfsNode(this.fs, path, contents2, false, dirty));
     } else if (dirty) {
       node.replace(contents2);
     }
@@ -9782,7 +9984,7 @@ var VfsNodes = class {
       if (writable && node.writers === 0) this.onClosed?.(node.path);
       return;
     }
-    if (this.byPath.get(node.path) === node) this.byPath.delete(node.path);
+    this.forget(node);
     this.kept.get(node)?.release();
     this.kept.delete(node);
     this.onClosed?.(node.path);
@@ -9798,7 +10000,7 @@ var VfsNodes = class {
   }
   keep(path, file) {
     const node = this.byPath.get(path);
-    if (!node) {
+    if (!node || this.dropName(path, node)) {
       file.release();
       return;
     }
@@ -9827,33 +10029,32 @@ var VfsNodes = class {
     }
   }
   revoke(prefix) {
-    for (const [path, node] of this.byPath) {
+    for (const [path, node] of [...this.byPath]) {
       if (!within5(path, prefix)) continue;
       node.revoke();
-      this.byPath.delete(path);
+      this.forget(node);
     }
   }
   unlinked(path) {
     for (const [held, node] of [...this.byPath]) {
-      if (!within5(held, path)) continue;
-      node.orphaned = true;
-      this.byPath.delete(held);
+      if (!within5(held, path) || this.byPath.get(held) !== node) continue;
+      if (!this.dropName(held, node)) this.orphan(node);
     }
   }
   renamed(from, to) {
     if (from === to) return;
     const moved2 = [];
-    for (const [p, node] of this.byPath) {
-      if (within5(p, from)) moved2.push(node);
-      else if (within5(p, to)) {
-        node.orphaned = true;
-        this.byPath.delete(p);
+    for (const [p, node] of [...this.byPath]) {
+      if (within5(p, from)) moved2.push([p, node]);
+      else if (within5(p, to) && this.byPath.get(p) === node && !this.dropName(p, node)) {
+        this.orphan(node);
       }
     }
-    for (const node of moved2) {
-      this.byPath.delete(node.path);
-      node.renamedTo(to + node.path.slice(from.length));
-      this.byPath.set(node.path, node);
+    for (const [p] of moved2) this.byPath.delete(p);
+    for (const [p, node] of moved2) {
+      const next2 = to + p.slice(from.length);
+      if (node.path === p) node.renamedTo(next2);
+      this.byPath.set(next2, node);
     }
   }
 };
@@ -9867,65 +10068,11 @@ async function present(fs, path, follow2 = false) {
     throw err;
   }
 }
-var MAX_LINKS5 = 40;
-function parentOf6(path) {
-  return path.slice(0, path.lastIndexOf("/")) || "/";
-}
-async function mustBeDir(fs, path) {
-  if (!fs.lstat) return;
-  const st = await fs.lstat(path);
-  if (st.isDirectory !== true) throw fsError("ENOTDIR", path);
-}
-async function linkOf(fs, path) {
-  return fs.readlink?.(path).catch(() => void 0);
-}
-async function realDir(fs, dir, budget = { hops: 0 }) {
-  const queue = dir.split("/").filter(Boolean);
-  let at = "/";
-  while (queue.length > 0) {
-    const part = queue.shift();
-    if (part === ".") continue;
-    if (part === "..") {
-      at = parentOf6(at);
-      continue;
-    }
-    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
-    const link2 = await linkOf(fs, next2);
-    if (link2 === void 0) {
-      if (queue.find((p) => p !== ".") === "..") await mustBeDir(fs, next2);
-      at = next2;
-      continue;
-    }
-    if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", dir);
-    budget.hops++;
-    queue.unshift(...link2.split("/").filter(Boolean));
-    if (link2.startsWith("/")) at = "/";
-  }
-  return at;
-}
 function errCode(err) {
   return err?.code;
 }
-function joinName(dir, name2) {
-  return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
-}
-async function realTarget(fs, path) {
-  const budget = { hops: 0 };
-  let dir = await realDir(fs, parentOf6(path), budget);
-  let name2 = path.slice(path.lastIndexOf("/") + 1);
-  for (; ; ) {
-    const link2 = await linkOf(fs, joinName(dir, name2));
-    if (link2 === void 0) break;
-    if (budget.hops >= MAX_LINKS5) throw fsError("ELOOP", path);
-    budget.hops++;
-    const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
-    dir = await realDir(fs, parentOf6(target), budget);
-    name2 = target.slice(target.lastIndexOf("/") + 1);
-  }
-  return joinName(dir, name2);
-}
 async function targetDir(fs, path) {
-  return parentOf6(await realTarget(fs, path).catch(() => path));
+  return parentOf5(await realTarget(fs, path).catch(() => path));
 }
 async function refuseReadonly(fs, path, flags, opts = {}) {
   const writes = (flags & O_ACCMODE) !== 0 || opts.truncate === true;
@@ -9961,6 +10108,15 @@ function keepingOpen(fs, nodes) {
     writeFile: (path, content, owner) => nodes.onEntry(fs.resolvePath("/", path), () => fs.writeFile(path, content, owner)),
     createExclusive: async (path, owner) => nodes.createExclusive(await nodes.entryKey(fs.resolvePath("/", path)), owner),
     symlink: (target, path, owner) => nodes.onEntry(fs.resolvePath("/", path), () => fs.symlink(target, path, owner)),
+    links: (path) => mayLink(fs, path),
+    link: async (from, to, follow2) => {
+      const source = fs.resolvePath("/", from);
+      const at = await (follow2 ? nodes.targetKey(source) : nodes.entryKey(source));
+      await nodes.flush(at);
+      const key = await nodes.entryKey(fs.resolvePath("/", to));
+      await nodes.onEntry(key, () => fs.link(from, to, follow2));
+      await nodes.linked(at, key);
+    },
     mkdir: (path, options) => nodes.onEntry(fs.resolvePath("/", path), () => fs.mkdir(path, options))
   };
 }
@@ -9968,7 +10124,7 @@ function vfsFile(fs, opts, nodes) {
   const access = opts.flags & O_ACCMODE;
   const readable = access !== O_WRONLY;
   const writable = access === O_WRONLY || access === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable) : nodes.open(opts.path, opts.pin, writable);
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable, opts.id) : nodes.open(opts.path, opts.pin, writable, opts.id);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -10403,12 +10559,12 @@ var WasmProcess = class {
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
           const fresh = this.options.owners && !await present(this.options.fs, path, true);
-          this.fds.installAt(fd, this.openVfsFile(open));
+          this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
           await this.fds.get(fd).file.stat?.();
           if (fresh) await this.options.fs.chown?.(path, { ...this.newOwner(), kind: "new" });
         });
       } else {
-        this.fds.installAt(fd, this.openVfsFile(open));
+        this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
       }
       if (req.existing && !await present(this.options.fs, path, true)) {
         throw new KernelError("ENOENT");
@@ -10439,7 +10595,7 @@ var WasmProcess = class {
     );
     return memoryFile(tree.read(path), path, req.position);
   }
-  openVfsFile(req) {
+  openVfsFile(req, id2) {
     return vfsFile(
       this.options.fs,
       {
@@ -10450,7 +10606,8 @@ var WasmProcess = class {
         ...req.orphan ? { orphan: true } : {},
         ...req.truncate ? { truncate: true } : {},
         ...req.create ? { create: true } : {},
-        ...req.pin ? { pin: req.pin } : {}
+        ...req.pin ? { pin: req.pin } : {},
+        ...id2 !== void 0 && !req.orphan ? { id: id2 } : {}
       },
       this.nodes
     );
@@ -10598,6 +10755,7 @@ var WasmProcess = class {
     }
     if (req.path === void 0) throw new KernelError("EINVAL");
     const path = req.orphan ? req.path : await this.keptOr(await this.nodes.targetKey(req.path), req.handle);
+    const id2 = req.orphan ? void 0 : await this.nodes.identify(path);
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
     const file = vfsFile(
       this.options.fs,
@@ -10608,7 +10766,8 @@ var WasmProcess = class {
         ...req.contents !== void 0 ? { contents: req.contents } : {},
         ...req.orphan ? { orphan: true } : {},
         ...req.dirty ? { dirty: true } : {},
-        ...req.pin ? { pin: req.pin } : {}
+        ...req.pin ? { pin: req.pin } : {},
+        ...id2 !== void 0 ? { id: id2 } : {}
       },
       this.nodes
     );
@@ -11680,6 +11839,9 @@ async function dispatch(h, req) {
       return h.unlink(req.path);
     case "rename":
       return h.rename(req.from, req.to);
+    case "link":
+      if (!h.link) throw fsError2("EPERM", "this file system has no hard links");
+      return h.link(req.from, req.to);
     case "symlink":
       if (!h.symlink) throw fsError2("EPERM", "this file system has no symlinks");
       return h.symlink(req.target, req.path);
@@ -12762,8 +12924,8 @@ var ChunkedBytes = class {
     }
     return out;
   }
-  write(offset, bytes, owned = false) {
-    const whole = owned && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength;
+  write(offset, bytes, owned2 = false) {
+    const whole = owned2 && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength;
     for (let done4 = 0; done4 < bytes.length; ) {
       const at = offset + done4;
       const index = Math.floor(at / CHUNK3);
@@ -12805,12 +12967,17 @@ function tmpfs() {
     mtime: Date.now(),
     data: new ChunkedBytes(),
     target: "",
-    children: /* @__PURE__ */ new Map()
+    children: /* @__PURE__ */ new Map(),
+    links: 1
   });
   const root = make("directory", 16877);
   const handles = /* @__PURE__ */ new Map();
   let nextFh = 0;
   const parts = (path) => path.split("/").filter(Boolean);
+  const place = (dir, name2, node) => {
+    dir.children.set(name2, node);
+    dir.mtime = Date.now();
+  };
   function find(path) {
     let node = root;
     for (const name2 of parts(path)) {
@@ -12834,7 +13001,8 @@ function tmpfs() {
     size: node.kind === "file" ? node.data.size : node.kind === "symlink" ? node.target.length : 4096,
     mtime: node.mtime,
     mode: node.mode,
-    ino: node.ino
+    ino: node.ino,
+    ...node.kind === "directory" ? {} : { nlink: node.links }
   });
   const handle = (fh) => {
     const found = handles.get(fh);
@@ -12849,8 +13017,7 @@ function tmpfs() {
     if (existing) return existing;
     if (!flags.create) throw fsError2("ENOENT", path);
     const node = make("file", 33188);
-    dir.children.set(name2, node);
-    dir.mtime = Date.now();
+    place(dir, name2, node);
     return node;
   }
   return {
@@ -12889,8 +13056,7 @@ function tmpfs() {
     async mkdir(path) {
       const { dir, name: name2 } = parent(path);
       if (dir.children.has(name2)) throw fsError2("EEXIST", path);
-      dir.children.set(name2, make("directory", 16877));
-      dir.mtime = Date.now();
+      place(dir, name2, make("directory", 16877));
     },
     async rmdir(path) {
       const { dir, name: name2 } = parent(path);
@@ -12907,6 +13073,7 @@ function tmpfs() {
       if (!node) throw fsError2("ENOENT", path);
       if (node.kind === "directory") throw fsError2("EISDIR", path);
       dir.children.delete(name2);
+      node.links--;
       dir.mtime = Date.now();
     },
     async rename(from, to) {
@@ -12923,17 +13090,25 @@ function tmpfs() {
         throw fsError2(node.kind === "directory" ? "ENOTEMPTY" : "EISDIR", to);
       }
       source.dir.children.delete(source.name);
+      if (replaced) replaced.links--;
       target.dir.children.set(target.name, node);
       source.dir.mtime = Date.now();
       target.dir.mtime = source.dir.mtime;
     },
+    async link(from, to) {
+      const node = find(from);
+      if (node.kind === "directory") throw fsError2("EPERM", `${from} is a directory`);
+      const { dir, name: name2 } = parent(to);
+      if (dir.children.has(name2)) throw fsError2("EEXIST", to);
+      place(dir, name2, node);
+      node.links++;
+    },
     async symlink(target, path) {
       const { dir, name: name2 } = parent(path);
       if (dir.children.has(name2)) throw fsError2("EEXIST", path);
       const node = make("symlink", 41471);
       node.target = target;
-      dir.children.set(name2, node);
-      dir.mtime = Date.now();
+      place(dir, name2, node);
     },
     async readlink(path) {
       const node = find(path);
@@ -13833,7 +14008,7 @@ var Launcher = class {
       serveFilesystem(
         port2,
         tmpfs(),
-        { symlinks: true, chmod: true, linkTimes: true, ranges: true, attrTtl: 0 },
+        { symlinks: true, links: true, chmod: true, linkTimes: true, ranges: true, attrTtl: 0 },
         { owned: true }
       );
       return {