@ai-ecoverse/slicc-kernel 1.94.1 → 1.94.2

package/dist/kernel-worker.js

@@ -8171,6 +8171,47 @@ var FileWatches = class {
   }
 };
 
+// src/fs/changes.ts
+var GEN = 0;
+var RING = 1;
+var RING_SIZE = 4096;
+var SLOT = 2;
+var CHANGES_BYTES = (RING + RING_SIZE * SLOT) * 4;
+function changeHash(path) {
+  let h = 2166136261;
+  for (let i = 0; i < path.length; i++) {
+    h ^= path.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h === 0 ? 1 : h;
+}
+function normal(path) {
+  const parts2 = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts2.pop();
+    else parts2.push(part);
+  }
+  return `/${parts2.join("/")}`;
+}
+var FileChanges = class {
+  sab;
+  view;
+  constructor(sab = new SharedArrayBuffer(CHANGES_BYTES)) {
+    this.sab = sab;
+    this.view = new Int32Array(sab);
+  }
+  publish(...paths) {
+    for (const path of paths) {
+      const g = Atomics.add(this.view, GEN, 1) + 1 | 0;
+      const at = RING + (g & RING_SIZE - 1) * SLOT;
+      Atomics.store(this.view, at, 0);
+      Atomics.store(this.view, at + 1, changeHash(normal(path)));
+      Atomics.store(this.view, at, g);
+    }
+  }
+};
+
 // src/fs/commands.ts
 var S_IFDIR2 = 16384;
 var S_IFREG2 = 32768;
@@ -8710,6 +8751,10 @@ function touches(watcher, changed) {
 }
 var FsWatchers = class {
   watchers = /* @__PURE__ */ new Set();
+  taps = [];
+  tap(listener) {
+    this.taps.push(listener);
+  }
   watch(paths, options, notify) {
     const watcher = {
       paths: paths.map(normalizePath),
@@ -8724,6 +8769,7 @@ var FsWatchers = class {
     };
   }
   changed(...paths) {
+    for (const tap of this.taps) tap(paths);
     for (const watcher of this.watchers) {
       for (const path of paths) {
         const changed = normalizePath(path);
@@ -10516,6 +10562,7 @@ var SYNC_FS_OPS = [
   "kept",
   "pread",
   "pwrite",
+  "append",
   "truncate",
   "chown",
   "lchown",
@@ -10711,6 +10758,8 @@ async function run(entry, path, req) {
     case "pwrite":
     case "truncate":
       return ranged(fs, path, req);
+    case "append":
+      return json2(await appended(fs, path, req.body ?? new Uint8Array(0)));
     default:
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
@@ -10803,6 +10852,7 @@ async function guard(g, path, req, cwd) {
       if (req.handle === void 0) await readable(g, op, path);
       return { path: await walkSafe(g, path, true) };
     case "pwrite":
+    case "append":
     case "truncate":
       if (req.handle === void 0) await fileWritable(g, op, path);
       return { path: await walkSafe(g, path, true) };
@@ -10863,7 +10913,7 @@ var CHANGING = /* @__PURE__ */ new Set([
   "chown",
   "lchown"
 ]);
-var CONTENT = /* @__PURE__ */ new Set(["write", "pwrite", "truncate"]);
+var CONTENT = /* @__PURE__ */ new Set(["write", "pwrite", "append", "truncate"]);
 var REMOVING = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm", "rename"]);
 async function mayChange(entry, path, req) {
   const { mayChange: mayChange2 } = entry.fs;
@@ -10901,6 +10951,30 @@ async function createExclusive(fs, path, owner) {
     throw syncError("EEXIST", path);
   await fs.writeFile(path, new Uint8Array(0), owner);
 }
+var appending = /* @__PURE__ */ new Map();
+async function appended(fs, path, body) {
+  const key = await fs.realpath?.(path, true).catch(() => void 0) ?? path;
+  const before = appending.get(key) ?? Promise.resolve();
+  const run2 = before.then(async () => {
+    if (fs.append) return fs.append(path, body);
+    const size = (await fs.stat(path)).size;
+    const ops = rangedOps(fs);
+    if (ops) await ops.pwrite(path, size, body, true);
+    else {
+      const whole = new Uint8Array(size + body.length);
+      whole.set(await fs.readFileBuffer(path));
+      whole.set(body, size);
+      await fs.writeFile(path, whole);
+    }
+    return size + body.length;
+  });
+  const settled = run2.catch(() => void 0);
+  appending.set(key, settled);
+  void settled.then(() => {
+    if (appending.get(key) === settled) appending.delete(key);
+  });
+  return run2;
+}
 async function ranged(fs, path, req) {
   const ops = rangedOps(fs);
   if (!ops) throw syncError("ENOSYS", path);
@@ -10916,7 +10990,7 @@ async function ranged(fs, path, req) {
   return done;
 }
 var CHOWN_OPS = /* @__PURE__ */ new Set(["chown", "lchown"]);
-var UNLINKED_OPS = /* @__PURE__ */ new Set(["read", "pread", "pwrite", "truncate"]);
+var UNLINKED_OPS = /* @__PURE__ */ new Set(["read", "pread", "pwrite", "append", "truncate"]);
 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"]);
@@ -11513,6 +11587,13 @@ var Pages = class {
     this.length = size;
     this.stored = size;
   }
+  refresh(size) {
+    if (this.pinned) return;
+    for (const page of [...this.pages.keys()]) if (!this.dirty.has(page)) this.drop(page);
+    const resized2 = this.length !== this.stored || this.shrink !== void 0;
+    if (this.shrink === void 0) this.stored = size;
+    this.length = resized2 ? Math.max(this.length, this.stored) : size;
+  }
   evict() {
     if (this.pinned) return;
     let clean = (this.pages.size - this.dirty.size) * PAGE;
@@ -11612,7 +11693,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.94.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.94.2" : "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
@@ -11814,10 +11895,10 @@ function normalize(path) {
   }
   return `/${out.join("/")}`;
 }
-var RING = 8;
-var RING_SIZE = 64;
-var SLOT = 3;
-var SHARED_IDS_BYTES = (RING + RING_SIZE * SLOT) * 4;
+var RING2 = 8;
+var RING_SIZE2 = 64;
+var SLOT2 = 3;
+var SHARED_IDS_BYTES = (RING2 + RING_SIZE2 * SLOT2) * 4;
 
 // src/process/wasi/wasi-procfs.ts
 var DIR_MODE = 16749;
@@ -13701,6 +13782,7 @@ var VfsNode = class {
   path;
   orphaned;
   id;
+  onDirty;
   constructor(fs, path, contents2, orphaned = false, dirty = false, pin) {
     this.fs = fs;
     this.pin = pin;
@@ -13850,6 +13932,7 @@ var VfsNode = class {
   }
   markDirty() {
     this.dirty = true;
+    if (!this.orphaned) this.onDirty?.();
     if (this.writeBack !== void 0 || this.orphaned) return;
     const delay = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
     this.writeBack = setTimeout(() => {
@@ -13885,6 +13968,7 @@ var VfsNodes = class {
   kept = /* @__PURE__ */ new Map();
   byId = /* @__PURE__ */ new Map();
   keepsOnDisk = false;
+  changed;
   fs;
   entries;
   onClosed;
@@ -13975,12 +14059,18 @@ var VfsNodes = class {
     if (node.path === path) node.renamedTo(others[0]);
     return true;
   }
+  holding(path) {
+    if (this.byPath.size === 0) return void 0;
+    const node = this.byPath.get(path);
+    return node && !node.orphaned ? node : void 0;
+  }
   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) {
+    node.onDirty = () => this.changed?.(node.path);
     this.byPath.set(path, node);
     if (id2 !== void 0) this.know(node, id2);
     return node;
@@ -14121,9 +14211,73 @@ async function refuseReadonly(fs, path, flags2, opts = {}) {
   const st = own ?? await stat(await targetDir(fs, path));
   if (st?.readonly) throw new KernelError("EROFS");
 }
-function keepingOpen(fs, nodes) {
+function heldIo(fs, nodes, changed) {
+  const ranged2 = rangedOps(fs);
+  const node = (path) => nodes.holding(fs.resolvePath("/", path));
+  const write = async (path, op, fallback) => {
+    const held = node(path);
+    if (!held) return fallback();
+    const out = await held.serial(async () => {
+      const done4 = await op(held);
+      await held.flush();
+      return done4;
+    });
+    changed(fs.resolvePath("/", path));
+    return out;
+  };
+  return {
+    append: (path, bytes) => write(
+      path,
+      async (held) => {
+        const at = await held.size();
+        await held.pwrite(bytes, at);
+        return at + bytes.length;
+      },
+      async () => {
+        const at = (await fs.stat(path)).size;
+        if (ranged2) await ranged2.pwrite(path, at, bytes, true);
+        else {
+          const whole = new Uint8Array(at + bytes.length);
+          whole.set(await fs.readFileBuffer(path));
+          whole.set(bytes, at);
+          await fs.writeFile(path, whole);
+        }
+        return at + bytes.length;
+      }
+    ),
+    async stat(path) {
+      const st = await fs.stat(path);
+      const held = st.isFile ? node(path) : void 0;
+      return held ? { ...st, size: await held.serial(() => held.size()) } : st;
+    },
+    async readFileBuffer(path) {
+      const held = 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);
+        return held ? held.serial(() => held.pread(n, at)) : ranged2.pread(path, at, n, version);
+      },
+      pwrite: (path, at, bytes, transfer) => write(
+        path,
+        async (held) => void await held.pwrite(bytes, at),
+        () => ranged2.pwrite(path, at, bytes, transfer)
+      ),
+      truncate: (path, size) => write(
+        path,
+        (held) => held.truncate(size),
+        () => ranged2.truncate(path, size)
+      )
+    } : {}
+  };
+}
+function keepingOpen(fs, nodes, changed = () => {
+}) {
   return {
     ...fs,
+    ...heldIo(fs, nodes, changed),
     async exclusive(path, run2, follow2 = true) {
       const at = fs.resolvePath("/", path);
       const key = follow2 ? nodes.targetKey(at) : nodes.entryKey(at);
@@ -14151,7 +14305,18 @@ function keepingOpen(fs, nodes) {
         nodes.renamed(a, b);
       });
     },
-    writeFile: (path, content, owner) => nodes.onEntry(fs.resolvePath("/", path), () => fs.writeFile(path, content, owner)),
+    writeFile: (path, content, owner) => {
+      const at = fs.resolvePath("/", path);
+      const held = nodes.holding(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 () => {
+        await held.truncate(0);
+        await held.pwrite(bytes, 0);
+        await held.flush();
+        changed(at);
+      });
+    },
     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),
@@ -15662,6 +15827,7 @@ function processInit(opts, sab, umask, cred, lane) {
     sab,
     umask,
     cred,
+    ...opts.changes ? { changes: opts.changes } : {},
     ...opts.owners ? { owners: true } : {},
     ...opts.links !== void 0 ? { links: true } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
@@ -19318,6 +19484,7 @@ var Launcher = class {
   resolver;
   hostname;
   watchers = new FsWatchers();
+  changes = new FileChanges();
   pnpmHome;
   pnpmChain;
   pnpmMade;
@@ -19369,6 +19536,7 @@ var Launcher = class {
     this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
     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.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
       busy: (target) => [...this.openFiles].some((nodes) => nodes.holds(target)) || heldUnder(this.held, target),
@@ -19506,9 +19674,9 @@ var Launcher = class {
   commands(scope = "") {
     let found = this.catalogs.get(scope);
     if (!found) {
-      found = this.trustedAppended().then(async (appended) => {
-        const tiers = await this.tiers(scope, appended);
-        return scanCommands(this.scanned, tiers, tiers.length - appended.length);
+      found = this.trustedAppended().then(async (appended2) => {
+        const tiers = await this.tiers(scope, appended2);
+        return scanCommands(this.scanned, tiers, tiers.length - appended2.length);
       }).then((commands) => commands.set(SUDO_COMMAND.name, SUDO_COMMAND));
       this.catalogs.set(scope, found);
     }
@@ -19536,11 +19704,11 @@ var Launcher = class {
     }
     return found;
   }
-  async tiers(scope = "", appended) {
+  async tiers(scope = "", appended2) {
     const system = [
       [this.modulesDir],
       await pnpmGlobalRoots(this.base, this.pnpmHome),
-      ...(appended ?? await this.trustedAppended()).map((root) => [root])
+      ...(appended2 ?? await this.trustedAppended()).map((root) => [root])
     ];
     return scope ? [await pnpmGlobalRoots(this.base, scope), ...system] : system;
   }
@@ -20093,6 +20261,7 @@ var Launcher = class {
       clipboard: this.clipboard,
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
+      changes: this.changes.sab,
       argv0: req.argv0,
       args: req.args,
       env: req.env,
@@ -20927,7 +21096,8 @@ var Launcher = class {
     );
   }
   processChain(fs, nodes, unlinked) {
-    return unlinked.wrap(keepingOpen(fs, nodes));
+    nodes.changed = (path) => this.changes.publish(path);
+    return unlinked.wrap(keepingOpen(fs, nodes, (path) => this.changes.publish(path)));
   }
   async starting(argv, dir, account, tag) {
     this.resetCatalogs();