@ai-ecoverse/slicc-kernel 1.98.1 → 1.98.3

package/dist/node.js

@@ -7651,9 +7651,19 @@ function touches(watcher, changed) {
     (watched) => changed === watched || under3(watched, changed) || (watcher.recursive ? under3(changed, watched) : parentOf6(changed) === watched)
   );
 }
+var REALS_KEPT = 4096;
 var FsWatchers = class {
   watchers = /* @__PURE__ */ new Set();
   taps = [];
+  reals = /* @__PURE__ */ new Map();
+  reshapes = [];
+  onReshape(listener) {
+    this.reshapes.push(listener);
+  }
+  reshaped() {
+    this.reals.clear();
+    for (const listener of this.reshapes) listener();
+  }
   tap(listener) {
     this.taps.push(listener);
   }
@@ -7697,8 +7707,41 @@ var FsWatchers = class {
         this.changed(...changed(...args));
       }
     };
+    const reals = this.reals;
+    const realOf = async (path) => {
+      const at = normalizePath(path);
+      const known = reals.get(at);
+      if (known !== void 0) return known;
+      if (!fs.realpath) return at;
+      let real;
+      try {
+        real = await fs.realpath(at, true);
+      } catch {
+        return at;
+      }
+      if (reals.size >= REALS_KEPT) reals.clear();
+      reals.set(at, real);
+      return real;
+    };
+    const content = (run2) => async (...args) => {
+      try {
+        await run2(...args);
+      } finally {
+        const at = normalizePath(args[0]);
+        const real = await realOf(at);
+        this.changed(...real === at ? [at] : [at, real]);
+      }
+    };
+    const reshaping = (run2) => async (...args) => {
+      this.reshaped();
+      try {
+        await run2(...args);
+      } finally {
+        this.reshaped();
+      }
+    };
     const overrides = {
-      writeFile: after(fs.writeFile.bind(fs), (path) => [path]),
+      writeFile: content(fs.writeFile.bind(fs)),
       mkdir: async (path, options) => {
         const created3 = [];
         if (options?.recursive) {
@@ -7714,13 +7757,15 @@ var FsWatchers = class {
           this.changed(...created3, path);
         }
       },
-      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]
+      rm: reshaping(after(fs.rm.bind(fs), (path) => [path])),
+      rename: reshaping(after(fs.rename.bind(fs), (from, to) => [from, to])),
+      link: reshaping(
+        after(
+          (from, to, follow2) => fs.link(from, to, follow2),
+          (_from, to) => [to]
+        )
       ),
-      symlink: after(fs.symlink.bind(fs), (_target, path) => [path]),
+      symlink: reshaping(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]) } : {},
       utimes: after(fs.utimes.bind(fs), (path) => [path]),
@@ -7731,8 +7776,8 @@ var FsWatchers = class {
     };
     const ranged2 = rangedOps(fs);
     if (ranged2) {
-      overrides.pwrite = after(ranged2.pwrite, (path) => [path]);
-      overrides.truncate = after(ranged2.truncate, (path) => [path]);
+      overrides.pwrite = content(ranged2.pwrite);
+      overrides.truncate = content(ranged2.truncate);
     }
     return new Proxy(fs, {
       get(target, key, receiver) {
@@ -8671,6 +8716,7 @@ var MountTable = class {
     };
     mounted = mount;
     this.mounts.set(target, mount);
+    this.deps.reshaped?.();
     this.notes.delete(target);
     return this.list().find((m) => m.target === target);
   }
@@ -8685,6 +8731,7 @@ var MountTable = class {
     if (!detach && this.deps.busy(at)) throw errnoError("EBUSY", `${at} has open files`);
     this.notes.delete(at);
     this.mounts.delete(at);
+    this.deps.reshaped?.();
     const waits = [...this.sessions].filter(([, s]) => s.mount === mount).map(([real]) => this.commit(real));
     for (const c of this.committing.values()) if (c.mount === mount) waits.push(c.done);
     const close = () => {
@@ -11028,7 +11075,7 @@ var PATH_OPS = new Set(SYNC_FS_OPS);
 var EARLY_WHOLE_FILE = 64 * 1024;
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.98.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.98.3" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -14556,6 +14603,7 @@ var VfsNodes = class {
     if (!this.byPath.has(to)) this.byPath.set(to, node);
   }
   know(node, id2) {
+    this.reshaped();
     node.id = id2;
     if (!this.byId.has(id2)) this.byId.set(id2, node);
   }
@@ -14565,6 +14613,7 @@ var VfsNodes = class {
     return out;
   }
   forget(node) {
+    this.reshaped();
     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);
   }
@@ -14579,6 +14628,38 @@ var VfsNodes = class {
     if (node.path === path) node.renamedTo(others[0]);
     return true;
   }
+  holdsAny() {
+    return this.byPath.size > 0;
+  }
+  epoch = 0;
+  plain = /* @__PURE__ */ new Map();
+  reshaped() {
+    this.epoch++;
+    this.plain.clear();
+  }
+  plainAt(path) {
+    return this.plain.get(path) === this.epoch;
+  }
+  get shape() {
+    return this.epoch;
+  }
+  notePlain(path, shape) {
+    if (shape !== this.epoch) return;
+    if (this.plain.size >= 4096) this.plain.clear();
+    this.plain.set(path, shape);
+  }
+  holdsName(name2) {
+    for (const path of this.byPath.keys())
+      if (path.slice(path.lastIndexOf("/") + 1) === name2) return true;
+    return false;
+  }
+  holdsLinked() {
+    return this.byId.size > 0;
+  }
+  holdingId(id2) {
+    const node = this.byId.get(id2);
+    return node && !node.orphaned ? node : void 0;
+  }
   holding(path) {
     if (this.byPath.size === 0) return void 0;
     const node = this.byPath.get(path);
@@ -14590,6 +14671,7 @@ var VfsNodes = class {
     return node;
   }
   create(path, id2, node) {
+    this.reshaped();
     node.onDirty = () => this.changed?.(node.path);
     this.byPath.set(path, node);
     if (id2 !== void 0) this.know(node, id2);
@@ -14731,11 +14813,35 @@ async function refuseReadonly(fs, path, flags2, opts = {}) {
   const st = own ?? await stat(await targetDir(fs, path));
   if (st?.readonly) throw new KernelError("EROFS");
 }
+var baseName = (path) => path.slice(path.lastIndexOf("/") + 1);
+async function byRealPath(fs, nodes, at) {
+  const real = await fs.realpath?.(at, true).catch(() => void 0);
+  return real === void 0 || real === at ? void 0 : nodes.holding(real);
+}
+async function aliasOf(fs, nodes, at) {
+  if (nodes.holdsName(baseName(at))) {
+    const named = await byRealPath(fs, nodes, at);
+    if (named) return named;
+  }
+  const st = await fs.lstat(at).catch(() => void 0);
+  if (!st) return void 0;
+  if (st.isSymbolicLink) return byRealPath(fs, nodes, at);
+  if (st.ino === void 0 || (st.nlink ?? 1) < 2 || !nodes.holdsLinked()) return void 0;
+  return nodes.holdingId(`${st.dev ?? 0}:${st.ino}`);
+}
+async function heldAt(fs, nodes, at) {
+  const held = nodes.holding(at);
+  if (held || !nodes.holdsAny() || nodes.plainAt(at)) return held;
+  const shape = nodes.shape;
+  const found = await aliasOf(fs, nodes, at);
+  if (!found) nodes.notePlain(at, shape);
+  return found;
+}
 function heldIo(fs, nodes, changed) {
   const ranged2 = rangedOps(fs);
-  const node = (path) => nodes.holding(fs.resolvePath("/", path));
+  const node = (path) => heldAt(fs, nodes, fs.resolvePath("/", path));
   const write = async (path, op, fallback) => {
-    const held = node(path);
+    const held = await node(path);
     if (!held) return fallback();
     const out = await held.serial(async () => {
       const done4 = await op(held);
@@ -14743,6 +14849,7 @@ function heldIo(fs, nodes, changed) {
       return done4;
     });
     changed(fs.resolvePath("/", path));
+    if (held.path !== fs.resolvePath("/", path)) changed(held.path);
     return out;
   };
   return {
@@ -14767,17 +14874,17 @@ function heldIo(fs, nodes, changed) {
     ),
     async stat(path) {
       const st = await fs.stat(path);
-      const held = st.isFile ? node(path) : void 0;
+      const held = st.isFile ? await node(path) : void 0;
       return held ? { ...st, size: await held.serial(() => held.size()) } : st;
     },
     async readFileBuffer(path) {
-      const held = node(path);
+      const held = await node(path);
       if (!held) return fs.readFileBuffer(path);
       return held.serial(async () => held.pread(await held.size(), 0));
     },
     ...ranged2 ? {
-      pread: (path, at, n, version) => {
-        const held = node(path);
+      pread: async (path, at, n, version) => {
+        const held = await node(path);
         return held ? held.serial(() => held.pread(n, at)) : ranged2.pread(path, at, n, version);
       },
       pwrite: (path, at, bytes, transfer) => write(
@@ -14825,9 +14932,9 @@ function keepingOpen(fs, nodes, changed = () => {
         nodes.renamed(a, b);
       });
     },
-    writeFile: (path, content, owner) => {
+    writeFile: async (path, content, owner) => {
       const at = fs.resolvePath("/", path);
-      const held = nodes.holding(at);
+      const held = await heldAt(fs, nodes, at);
       if (!held) return nodes.onEntry(at, () => fs.writeFile(path, content, owner));
       const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
       return held.serial(async () => {
@@ -14835,6 +14942,7 @@ function keepingOpen(fs, nodes, changed = () => {
         await held.pwrite(bytes, 0);
         await held.flush();
         changed(at);
+        if (held.path !== at) changed(held.path);
       });
     },
     createExclusive: async (path, owner) => nodes.createExclusive(await nodes.entryKey(fs.resolvePath("/", path)), owner),
@@ -15070,6 +15178,11 @@ function clipboardLine(text) {
   }
   return out.length > 200 ? `${out.slice(0, 200)}\u2026` : out;
 }
+var nextOpenKey = 1;
+var fileKeys = /* @__PURE__ */ new WeakMap();
+function identityKey(st, path) {
+  return st.ino === void 0 ? path : `${st.dev ?? 0}:${st.ino}`;
+}
 var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
@@ -15315,10 +15428,11 @@ var WasmProcess = class {
     this.lockOwners.add(owner);
     return owner;
   }
+  pathKeys = /* @__PURE__ */ new Map();
   async lockPath(target, want) {
     if (target.fd !== void 0) {
       const st = await this.fds.get(target.fd).file.stat?.();
-      if (!st || st.orphan) throw new KernelError("EBADF");
+      if (!st) throw new KernelError("EBADF");
       return st.path;
     }
     if (target.path === void 0) throw new KernelError("EINVAL");
@@ -15333,11 +15447,22 @@ var WasmProcess = class {
     return path;
   }
   async lockKey(target, kind) {
+    const file = target.fd === void 0 ? void 0 : this.fds.get(target.fd);
+    const known = file ? fileKeys.get(file) : this.pathKeys.get(target.path ?? "");
+    if (kind === "close" && !file && target.path !== void 0) this.pathKeys.delete(target.path);
     const want = kind === "read" ? R_OK : kind === "write" ? W_OK : 0;
     const path = await this.lockPath(target, want);
-    const st = await this.options.fs.stat?.(path);
-    if (!st) throw new KernelError("ENOENT");
-    return st.ino === void 0 ? path : `${st.dev ?? 0}:${st.ino}`;
+    if (known !== void 0) return known;
+    const st = await this.options.fs.stat?.(path).catch((err) => {
+      if (!file) throw err;
+      return void 0;
+    });
+    if (!st && !file) throw new KernelError("ENOENT");
+    const key = st ? identityKey(st, path) : `open:${nextOpenKey++}`;
+    if (kind === "close") return key;
+    if (file) fileKeys.set(file, key);
+    else if (this.pathKeys.size < 4096) this.pathKeys.set(path, key);
+    return key;
   }
   async dropRecordLocks(fd) {
     const { locks } = this.options;
@@ -19980,7 +20105,7 @@ function usersMode(mode = "off") {
 function tagOption(tag) {
   if (tag !== void 0 && typeof tag !== "string") throw new TypeError("a tag must be a string");
 }
-function baseName(path) {
+function baseName2(path) {
   return path.slice(path.lastIndexOf("/") + 1);
 }
 function packageRootOf(path, roots) {
@@ -20023,7 +20148,7 @@ function appendedRoots(given) {
 }
 function plainEnv(words2) {
   const next2 = words2[1];
-  if (baseName(words2[0] ?? "") !== "env" || next2 === void 0) return false;
+  if (baseName2(words2[0] ?? "") !== "env" || next2 === void 0) return false;
   return next2 === "-S" || !next2.startsWith("-") && !next2.includes("=");
 }
 function shebangCommand(words2) {
@@ -20039,9 +20164,9 @@ function shebangCommand(words2) {
 function interpreter(head) {
   const words2 = shebang(head);
   if (!words2) return "node";
-  if (baseName(words2[0]) === "env") words2.shift();
+  if (baseName2(words2[0]) === "env") words2.shift();
   if (words2[0] === "-S") words2.shift();
-  return baseName(words2[0] ?? "");
+  return baseName2(words2[0] ?? "");
 }
 function expandDefaults(defaults, env) {
   const out = {};
@@ -20215,6 +20340,9 @@ var Launcher = class {
     this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
     if (this.owners) options.fs.trackOwners?.();
     this.watchers.tap((paths) => this.changes.publish(...paths));
+    this.watchers.onReshape(() => {
+      for (const nodes of this.openFiles) nodes.reshaped();
+    });
     this.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
       busy: (target) => [...this.openFiles].some((nodes) => nodes.holds(target)) || heldUnder(this.held, target),
@@ -20222,6 +20350,7 @@ var Launcher = class {
         if (paths.some((path) => this.pnpmChain.has(path))) this.pnpmStale();
         this.watchers.changed(...paths);
       },
+      reshaped: () => this.watchers.reshaped(),
       owners: this.owners
     });
     this.mounted = this.mounts.wrap(options.fs);
@@ -20479,22 +20608,22 @@ var Launcher = class {
     const head = await this.head(glue);
     if (!head) return void 0;
     if (isWasm(head)) {
-      const owner2 = await this.wasmOwner(glue, baseName(file).replace(/\.wasm$/, ""), scope);
+      const owner2 = await this.wasmOwner(glue, baseName2(file).replace(/\.wasm$/, ""), scope);
       if (owner2) return { ...targetOf(owner2), ...asked };
       return {
         abi: "wasi",
         glue,
         wasm: glue,
-        argv0: baseName(argv0 || file).replace(/\.wasm$/, ""),
+        argv0: baseName2(argv0 || file).replace(/\.wasm$/, ""),
         ...asked
       };
     }
     if (interpreter(head) !== "node") return void 0;
     const wasm = modulePath(glue);
     if (await this.base.exists(wasm)) {
-      return { abi: "emscripten", glue, wasm, argv0: baseName(argv0 || file), ...asked };
+      return { abi: "emscripten", glue, wasm, argv0: baseName2(argv0 || file), ...asked };
     }
-    const owner = await this.glueOwner(glue, baseName(file), scope);
+    const owner = await this.glueOwner(glue, baseName2(file), scope);
     return owner && { ...targetOf(owner), ...asked };
   }
   async glueOwner(glue, name2, scope) {
@@ -20504,11 +20633,11 @@ var Launcher = class {
     return owners.find((c) => c.name === name2) ?? owners[0];
   }
   async wasmOwner(wasm, name2, scope) {
-    const leaf = baseName(wasm);
+    const leaf = baseName2(wasm);
     const real = await physicalPathAsync(this.base, wasm);
     const owners = [];
     for (const command of (await this.commands(scope)).values()) {
-      if (command.abi !== "wasi" || command.script || baseName(command.wasm) !== leaf) continue;
+      if (command.abi !== "wasi" || command.script || baseName2(command.wasm) !== leaf) continue;
       if (command.wasm === wasm || await physicalPathAsync(this.base, command.wasm) === real)
         owners.push(command);
     }
@@ -21572,7 +21701,7 @@ var Launcher = class {
     const path = normalizePath(given);
     if (!await this.base.exists(path)) return void 0;
     if (path === "/") return path;
-    return joinName(await realDir(this.base, parentOf(path)), baseName(path));
+    return joinName(await realDir(this.base, parentOf(path)), baseName2(path));
   }
   pnpmReady() {
     if (this.pnpmMade !== void 0) return this.pnpmMade;