@ai-ecoverse/slicc-kernel 1.71.1 → 1.73.0

package/dist/kernel-worker.js

@@ -141,11 +141,18 @@ var IndexedDbMeta = class {
   cache = new PathMap();
   channel;
   generation = 0;
+  listeners = /* @__PURE__ */ new Set();
+  listen(listener) {
+    this.listeners.add(listener);
+  }
   constructor(db) {
     this.db = db;
     db.onversionchange = () => db.close();
     this.channel = new BroadcastChannel(`slicc-kernel-meta:${db.name}`);
-    this.channel.onmessage = ({ data }) => this.drop(data);
+    this.channel.onmessage = ({ data }) => {
+      this.drop(data);
+      for (const listener of this.listeners) listener(data);
+    };
     this.channel.unref?.();
   }
   drop({ paths = [], trees = [] }) {
@@ -354,7 +361,17 @@ async function chownAs(fs, cred, path, change) {
 }
 
 // src/fs/protect.ts
-var PROTECT_WRITER = "slicc-kernel: protect.writer needs the process tag (#405), which this kernel does not have yet";
+function protectInit(protection) {
+  const writers = [...writerTags(protection)];
+  return { paths: [...protection.paths], ...writers.length > 0 ? { writers } : {} };
+}
+function writerTags(protection) {
+  const writers = protection?.writers ?? [];
+  if (!Array.isArray(writers) || writers.some((tag) => typeof tag !== "string" || tag === "")) {
+    throw new TypeError("protect.writers must be a list of process tags");
+  }
+  return new Set(writers);
+}
 function protectedPrefixes(paths) {
   return [...new Set(paths.map((p) => normalizePath(p)))];
 }
@@ -530,6 +547,121 @@ var ProtectedFs = class {
   }
 };
 
+// src/fs/remote.ts
+var ANNOUNCE_WAIT_MS = 500;
+var PRUNE_EVERY_MS = 3e4;
+function lockManager() {
+  return globalThis.navigator?.locks;
+}
+var RemoteWatch = class {
+  channel;
+  name;
+  tab = crypto.randomUUID();
+  peers = /* @__PURE__ */ new Set();
+  others = /* @__PURE__ */ new Map();
+  union = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  waiting = /* @__PURE__ */ new Map();
+  locks;
+  mine = [];
+  seq = 0;
+  pruned = 0;
+  constructor(name2, options = {}) {
+    this.name = name2;
+    this.locks = options.locks === void 0 ? lockManager() : options.locks ?? void 0;
+    this.channel = new BroadcastChannel(name2);
+    this.channel.onmessage = ({ data }) => this.receive(data);
+    this.channel.unref?.();
+    void this.locks?.request(this.lockOf(this.tab), () => new Promise(() => {
+    }));
+    this.channel.postMessage({ hello: this.tab });
+  }
+  lockOf(tab) {
+    return `${this.name}:${tab}`;
+  }
+  receive(data) {
+    if (data.hello !== void 0) this.greeted(data.hello);
+    if (data.here !== void 0 && data.to === this.tab) this.peers.add(data.here);
+    if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
+    if (data.ack !== void 0 && data.to === this.tab && data.from !== void 0) {
+      this.acked(data.ack, data.from);
+    }
+    if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [] });
+  }
+  greeted(peer) {
+    this.peers.add(peer);
+    this.channel.postMessage({ here: this.tab, to: peer });
+    if (this.mine.length > 0) void this.announce(this.mine);
+  }
+  announced({ tab, paths, seq: seq2 }) {
+    const from = tab;
+    this.peers.add(from);
+    if (paths.length > 0) this.others.set(from, paths);
+    else this.others.delete(from);
+    this.rebuild();
+    this.channel.postMessage({ ack: seq2, from: this.tab, to: from });
+  }
+  acked(seq2, from) {
+    const wait2 = this.waiting.get(seq2);
+    if (!wait2) return;
+    wait2.left.delete(from);
+    if (wait2.left.size === 0) wait2.done();
+  }
+  rebuild() {
+    this.union.clear();
+    for (const paths of this.others.values()) for (const path of paths) this.union.add(path);
+  }
+  async prune() {
+    if (!this.locks) return;
+    const held = new Set(((await this.locks.query()).held ?? []).map((lock) => lock.name));
+    for (const tab of /* @__PURE__ */ new Set([...this.others.keys(), ...this.peers])) {
+      if (!held.has(this.lockOf(tab))) {
+        this.others.delete(tab);
+        this.peers.delete(tab);
+      }
+    }
+    this.rebuild();
+  }
+  watched() {
+    return this.union.size > 0;
+  }
+  wrote(path) {
+    if (!this.union.has(path)) return;
+    this.channel.postMessage({ changed: [path] });
+    const now = Date.now();
+    if (now - this.pruned < PRUNE_EVERY_MS) return;
+    this.pruned = now;
+    void this.prune();
+  }
+  announce(paths) {
+    this.mine = [...paths];
+    const seq2 = ++this.seq;
+    this.channel.postMessage({ tab: this.tab, paths: this.mine, seq: seq2 });
+    if (this.peers.size === 0) return Promise.resolve();
+    return new Promise((resolve) => {
+      const done4 = () => {
+        clearTimeout(timer);
+        this.waiting.delete(seq2);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        done4();
+        void this.prune();
+      }, ANNOUNCE_WAIT_MS);
+      this.waiting.set(seq2, { left: new Set(this.peers), done: done4 });
+    });
+  }
+  emit(change) {
+    for (const listener of this.listeners) listener(change);
+  }
+  listen(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+};
+
 // src/fs/opfs.ts
 var S_IFDIR = 16384;
 var S_IFREG = 32768;
@@ -657,6 +789,7 @@ var OpfsFs = class {
   dirs = new PathMap();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
+  remote;
   ranged;
   owners = false;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
@@ -664,9 +797,15 @@ var OpfsFs = class {
     this.meta = sidecar(meta);
     this.ranged = options.ranged === true;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
+    this.remote = channel === void 0 ? void 0 : new RemoteWatch(`${channel}:watch`);
     if (this.channel) {
+      const remote = this.remote;
+      meta.listen?.(
+        (c) => remote?.emit({ paths: c.paths ?? [], trees: c.trees ?? [] })
+      );
       this.channel.onmessage = ({ data }) => {
         for (const path of data) this.forget(path);
+        remote?.emit({ paths: data, trees: [] });
       };
       this.channel.unref?.();
     }
@@ -675,6 +814,16 @@ var OpfsFs = class {
     for (const path of paths) this.forget(path);
     this.channel?.postMessage(paths);
   }
+  remoteChanges(listener) {
+    return this.remote?.listen(listener) ?? (() => {
+    });
+  }
+  announceWatch(paths) {
+    return this.remote?.announce(paths) ?? Promise.resolve();
+  }
+  committed(target) {
+    if (this.remote?.watched()) this.remote.wrote(target);
+  }
   resolvePath(base, path) {
     return resolvePath(base, path);
   }
@@ -734,6 +883,9 @@ var OpfsFs = class {
   protect(prefixes2) {
     this.guarded = prefixes2;
   }
+  unguarded() {
+    return Object.create(this, { guarded: { value: [] } });
+  }
   refuse(path, holding = false) {
     if (isProtected(this.guarded, path) || holding && holdsProtected(this.guarded, path)) {
       throw fsError("EROFS", path);
@@ -903,15 +1055,15 @@ var OpfsFs = class {
   }
   dirTimes = /* @__PURE__ */ new Map();
   dirDirty = /* @__PURE__ */ new Set();
-  dirFlush;
+  flushing = {};
   touch(...dirs) {
     const now = Date.now();
     for (const dir of dirs) {
       this.dirTimes.set(dir, now);
       this.dirDirty.add(dir);
     }
-    this.dirFlush ??= Promise.resolve().then(() => this.flushDirTimes()).catch(() => void 0).finally(() => {
-      this.dirFlush = void 0;
+    this.flushing.dir ??= Promise.resolve().then(() => this.flushDirTimes()).catch(() => void 0).finally(() => {
+      this.flushing.dir = void 0;
     });
   }
   async flushDirTimes() {
@@ -1026,15 +1178,18 @@ var OpfsFs = class {
     );
   }
   async pwrite(path, offset, bytes) {
-    const handle = (await this.fileFor(path))[0];
+    const [handle, , target] = await this.fileFor(path);
     await this.retrying(path, () => positioned(handle, (io) => io.write(offset, bytes)), true);
+    this.committed(target);
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
+    const target = this.remote?.watched() ? (await this.locate(path, true)).path : path;
     await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
+    this.committed(target);
   }
   async writeSession(path, truncate) {
-    const handle = (await this.fileFor(path))[0];
+    const [handle, , target] = await this.fileFor(path);
     const writable2 = await this.retrying(
       path,
       () => handle.createWritable({ keepExistingData: !truncate }),
@@ -1047,9 +1202,12 @@ var OpfsFs = class {
       truncate: (size) => writable2.truncate(size).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      close: () => writable2.close().catch((err) => {
-        throw translate(err, path, "commit", false);
-      })
+      close: async () => {
+        await writable2.close().catch((err) => {
+          throw translate(err, path, "commit", false);
+        });
+        this.committed(target);
+      }
     };
   }
   async readFile(path) {
@@ -1098,6 +1256,7 @@ var OpfsFs = class {
       await writable2?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
     }
+    this.committed(target);
   }
   async listing(path) {
     const found = await this.locate(path, true);
@@ -1119,12 +1278,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 owned3 = (stat, entry) => handed2 ? { ...stat, ...ownOf(entry) ?? handed2 } : stat;
+    const owned4 = (stat, entry) => handed2 ? { ...stat, ...ownOf(entry) ?? handed2 } : stat;
     return Promise.all(
       children2.map(async ([name2, child], i) => {
-        if (!isHandle(child)) return [name2, owned3(this.linkStat(child), child)];
+        if (!isHandle(child)) return [name2, owned4(this.linkStat(child), child)];
         const stat = await this.statOf(`${base}/${name2}`, child, metas[i]).catch(() => null);
-        return [name2, stat && owned3(stat, metas[i])];
+        return [name2, stat && owned4(stat, metas[i])];
       })
     );
   }
@@ -1733,6 +1892,7 @@ var Dac = class {
   log;
   seen = /* @__PURE__ */ new Set();
   suppressed = false;
+  tagOf = () => void 0;
   constructor(mode, hook, log = (line) => console.warn(line)) {
     this.mode = mode;
     this.hook = hook;
@@ -1741,7 +1901,9 @@ var Dac = class {
   get enforcing() {
     return this.mode === "enforce";
   }
-  denied(denial) {
+  denied(given) {
+    const tag = given.tag ?? (given.pid ? this.tagOf(given.pid) : void 0);
+    const denial = tag === void 0 ? given : { ...given, tag };
     try {
       this.hook?.({ ...denial });
     } catch {
@@ -1759,7 +1921,7 @@ var Dac = class {
     }
     this.seen.add(key);
     this.log(
-      `slicc-kernel users report: ${d.errno} ${d.op} ${d.path} (uid ${d.uid}, pid ${d.pid})`
+      `slicc-kernel users report: ${d.errno} ${d.op} ${d.path} (uid ${d.uid}, pid ${d.pid}${d.tag === void 0 ? "" : `, tag ${d.tag}`})`
     );
   }
 };
@@ -1775,7 +1937,8 @@ var Created = class {
   }
 };
 function deny(g, op, path, errno = "EACCES") {
-  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno });
+  const tag = g.tag === void 0 ? {} : { tag: g.tag };
+  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno, ...tag });
 }
 var TTY_MODE = 400;
 function ttyOpenable(g, tty) {
@@ -3671,6 +3834,12 @@ var CLIENT_CHECKS = {
   readlink: (g, at) => searchable(g, "readlink", at(0), false),
   exists: (g, at) => searchable(g, "exists", at(0), true)
 };
+function clientFs(l, tag, self, req) {
+  if (!FS_METHODS.includes(req.method)) {
+    throw new Error(`unknown file system call ${req.method}`);
+  }
+  return fsCall(l.fsFor(tag), req.method, req.args, ownerFor(l, self), guardFor(l, self, tag));
+}
 async function fsCall(fs, method, args, owner, g) {
   const path = (i) => fs.resolvePath("/", String(args[i]));
   if (g) {
@@ -3745,9 +3914,9 @@ function ownerFor(l, self) {
   if (!l.owners || !self) return void 0;
   return { uid: self.uid, gid: self.gid, umask: self.umask ?? 18 };
 }
-function guardFor(l, self) {
+function guardFor(l, self, tag) {
   if (!l.dac || !self) return void 0;
-  return { fs: l.fs, cred: credOf(self), pid: 0, dac: l.dac };
+  return { fs: l.fs, cred: credOf(self), pid: 0, dac: l.dac, tag };
 }
 async function accountOf(l, user) {
   const found = await l.users.lookup(user);
@@ -3851,6 +4020,7 @@ async function watchOp(l, req, watches, send, g) {
 function serveClient(port, host) {
   let state = "new";
   let self;
+  const guard2 = (l) => guardFor(l, self, host.tag);
   const terminals = /* @__PURE__ */ new Map();
   const groups = /* @__PURE__ */ new Set();
   const sessions = /* @__PURE__ */ new Set();
@@ -3957,13 +4127,10 @@ function serveClient(port, host) {
       case "ps":
         return { result: processes(l, self) };
       case "fs":
-        if (!FS_METHODS.includes(req.method)) {
-          throw new Error(`unknown file system call ${req.method}`);
-        }
-        return fsCall(l.processFs, req.method, req.args, ownerFor(l, self), guardFor(l, self));
+        return clientFs(l, host.tag, self, req);
       case "watch":
       case "unwatch":
-        return watchOp(l, req, watches, send, guardFor(l, self));
+        return watchOp(l, req, watches, send, guard2(l));
       case "mount":
         return { result: await l.mountAs(clientCred(self), req.spec) };
       case "umount":
@@ -6624,6 +6791,136 @@ function binfmtOf(binfmts, path) {
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
+// src/fs/attest.ts
+var ATTEST_MAX = 1024 * 1024;
+var UNOWNED = 1e3;
+function refuse(code, path, why) {
+  throw Object.assign(new Error(`attest ${path}: ${why}`), { code });
+}
+function chainOf(path) {
+  const parts2 = path.split("/").filter(Boolean);
+  return ["/", ...parts2.map((_, i) => `/${parts2.slice(0, i + 1).join("/")}`)];
+}
+function under2(path, target) {
+  return path === target || path.startsWith(`${target}/`);
+}
+function owned(path, st) {
+  return { path, uid: st.uid ?? UNOWNED, gid: st.gid ?? UNOWNED, mode: st.mode };
+}
+function unchanged(a, b, bytes) {
+  return a.ino === b.ino && a.mtime.getTime() === b.mtime.getTime() && a.size === b.size && bytes.length === b.size;
+}
+async function sha256(bytes) {
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", bytes)
+  );
+  return Array.from(digest, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function attested(path, st, bytes, digest, o, parents) {
+  const { uid, gid, mode } = owned(path, st);
+  return {
+    path,
+    bytes,
+    uid,
+    gid,
+    mode,
+    ino: st.ino,
+    mtimeMs: st.mtime.getTime(),
+    sha256: digest,
+    users: o.users,
+    onRootFs: true,
+    parents
+  };
+}
+async function trustedParents(fs, path, o) {
+  const parents = [];
+  for (const dir of chainOf(path).slice(0, -1)) {
+    const st = await fs.lstat(dir);
+    if (st.isSymbolicLink) refuse("EACCES", path, `${dir} is a symlink`);
+    if (!st.isDirectory) refuse("ENOTDIR", path, `${dir} is not a directory`);
+    const perm = owned(dir, st);
+    if (o.users !== "off" && (perm.uid !== 0 || (perm.mode & 18) !== 0)) {
+      refuse("EACCES", path, `${dir} is not root-owned or is writable by group or others`);
+    }
+    parents.push(perm);
+  }
+  return parents;
+}
+async function attest(fs, asked, o) {
+  if (typeof asked !== "string" || !asked.startsWith("/")) {
+    refuse("EINVAL", String(asked), "not an absolute path");
+  }
+  const path = normalizePath(asked);
+  const mount = o.mounts.find((target) => {
+    const at = normalizePath(target);
+    return at === "/" || under2(path, at);
+  });
+  if (mount !== void 0) refuse("EACCES", path, `under the mount ${mount}`);
+  const parents = await trustedParents(fs, path, o);
+  for (let tries = 0; ; tries++) {
+    const before = await fs.lstat(path);
+    if (before.isSymbolicLink) refuse("EACCES", path, "is a symlink");
+    if (!before.isFile)
+      refuse(before.isDirectory ? "EISDIR" : "EINVAL", path, "is not a regular file");
+    if (before.size > ATTEST_MAX) refuse("EFBIG", path, `is over ${ATTEST_MAX} bytes`);
+    const bytes = (await fs.readFileBuffer(path)).slice();
+    const after = await fs.lstat(path);
+    if (unchanged(before, after, bytes)) {
+      return attested(path, after, bytes, await sha256(bytes), o, parents);
+    }
+    if (tries >= 1) refuse("EAGAIN", path, "changed while it was read");
+  }
+}
+var WATCH_DEBOUNCE_MS = 50;
+var FileWatches = class {
+  live = /* @__PURE__ */ new Set();
+  local;
+  remote;
+  constructor(local, remote) {
+    this.local = local;
+    this.remote = remote;
+  }
+  announce() {
+    return this.remote.announceWatch?.([...new Set([...this.live].flat())]) ?? Promise.resolve();
+  }
+  async watch(paths, notify) {
+    const files = paths.map(normalizePath);
+    const timers = /* @__PURE__ */ new Map();
+    let active = true;
+    const fire = (changed, trees) => {
+      for (const file of files) {
+        const hit = [...changed, ...trees].some((p) => under2(file, normalizePath(p)));
+        if (!hit) continue;
+        clearTimeout(timers.get(file));
+        timers.set(
+          file,
+          setTimeout(() => {
+            timers.delete(file);
+            if (active) notify(file);
+          }, WATCH_DEBOUNCE_MS)
+        );
+      }
+    };
+    const unwatch = this.local.watch(
+      files,
+      { recursive: false },
+      (change) => fire("overflow" in change ? files : change.paths, [])
+    );
+    const unlisten = this.remote.remoteChanges?.((change) => fire(change.paths, change.trees));
+    this.live.add(files);
+    await this.announce();
+    return () => {
+      if (!active) return;
+      active = false;
+      for (const timer of timers.values()) clearTimeout(timer);
+      unwatch();
+      unlisten?.();
+      this.live.delete(files);
+      void this.announce();
+    };
+  }
+};
+
 // src/fs/commands.ts
 var S_IFDIR2 = 16384;
 var S_IFREG2 = 32768;
@@ -6662,7 +6959,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     if (st || path === "/") return st ?? {};
     return nearest(path.slice(0, path.lastIndexOf("/")) || "/");
   }
-  async function owned3(stat2, dir) {
+  async function owned4(stat2, dir) {
     if (!owners) return stat2;
     const { uid = 0, gid = 0 } = dir === void 0 ? {} : await nearest(dir);
     return { ...stat2, uid, gid };
@@ -6676,17 +6973,17 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
   }
   async function virtual(path) {
     if (path === "/usr" || path === "/bin" || path === "/usr/bin") {
-      return owned3(synthetic(true, path));
+      return owned4(synthetic(true, path));
     }
     const name2 = COMMAND.exec(path)?.[1];
     if (name2 !== void 0) {
-      return (await names()).has(name2) ? owned3(synthetic(false, path)) : void 0;
+      return (await names()).has(name2) ? owned4(synthetic(false, path)) : void 0;
     }
-    if ((await userDir(path))?.size) return owned3(synthetic(true, path), path);
+    if ((await userDir(path))?.size) return owned4(synthetic(true, path), path);
     const slash = path.lastIndexOf("/");
     const dir = path.slice(0, slash);
     const own = await userDir(dir);
-    return own?.has(path.slice(slash + 1)) ? owned3(synthetic(false, path), dir) : void 0;
+    return own?.has(path.slice(slash + 1)) ? owned4(synthetic(false, path), dir) : void 0;
   }
   async function linked(path) {
     return await virtual(path) ?? virtual(await followLinks(fs, path));
@@ -7035,11 +7332,11 @@ var UnlinkedKeeper = class {
 
 // src/fs/watch.ts
 var WATCH_BATCH_LIMIT = 1e3;
-var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
+var under3 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
 var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 function touches(watcher, changed) {
   return watcher.paths.some(
-    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf6(changed) === watched)
+    (watched) => changed === watched || under3(watched, changed) || (watcher.recursive ? under3(changed, watched) : parentOf6(changed) === watched)
   );
 }
 var FsWatchers = class {
@@ -8758,7 +9055,7 @@ async function keptStat(entry, req) {
     return { ok: false, errno: "ENOENT", message: "the handle keeps no file" };
   return json2(statJson(await entry.fs.stat(hidden)));
 }
-async function owned(entry, own, req, path, target) {
+async function owned2(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);
@@ -8813,7 +9110,7 @@ async function dispatchOne(entry, req) {
     }
     if (!entry.own || !OWN_OPS.has(req.op)) return await 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);
+    return await owned2(entry, entry.own, req, path, target);
   } catch (err) {
     return toErrno(err);
   }
@@ -11668,6 +11965,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-sudo",
   "proc-run",
   "proc-exit",
+  "proc-kill-self",
   "proc-fork",
   "proc-kill",
   "thread-kill",
@@ -11795,6 +12093,20 @@ var WasmProcess = class {
     else this.adoptExec(pid);
     return pid;
   }
+  async killSelf(sig, target, probe) {
+    if (!this.options.exitSignal) throw new KernelError("ENOSYS");
+    if (!isSignal(sig) || defaultAction(sig) !== "terminate") throw new KernelError("EINVAL");
+    const { caught, ignored } = this.signalMasks();
+    const to = target === 0 ? -this.pgid() : target ?? this.pid;
+    if (sig !== SIG.KILL && (caught | ignored) & sigbit(sig)) {
+      if (!await this.options.kill?.(to, sig)) throw new KernelError("ESRCH");
+      return { ok: true, kind: "void" };
+    }
+    if (probe) return { ok: true, kind: "json", json: "terminate" };
+    if (to !== this.pid) await this.options.kill?.(to, sig);
+    this.options.exitSignal(sig);
+    return DYING;
+  }
   run(req) {
     return runChild(req, {
       children: this.children,
@@ -12392,6 +12704,8 @@ var WasmProcess = class {
         if (!this.options.exitNow) throw new KernelError("ENOSYS");
         this.options.exitNow(req.status & 255);
         return DYING;
+      case "proc-kill-self":
+        return this.killSelf(req.sig, req.target, req.probe);
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
@@ -12826,6 +13140,7 @@ function processOptions(opts, header3, hooks, created3) {
     raise: hooks.raise,
     threadKill: hooks.threadKill,
     ...hooks.exitNow ? { exitNow: hooks.exitNow } : {},
+    ...hooks.exitSignal ? { exitSignal: hooks.exitSignal } : {},
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header3, SAB_I_SIGNALS) } : {}
   };
 }
@@ -12859,7 +13174,10 @@ function spawnWasmProcess(opts) {
       {
         raise: (sig) => signal(sig),
         threadKill: (tid, sig) => killThread(threadSignals.get(tid), process.signalMasks().caught, sig),
-        ...opts.program.abi === "js" ? { exitNow: (code) => exitNow(code) } : {}
+        ...opts.program.abi === "js" ? {
+          exitNow: (code) => exitNow(code),
+          exitSignal: (sig) => queueMicrotask(() => finish(128 + sig, sig))
+        } : {}
       },
       created3
     )
@@ -14664,8 +14982,8 @@ var ChunkedBytes = class {
     }
     return out;
   }
-  write(offset, bytes, owned3 = false) {
-    const whole = owned3 && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength;
+  write(offset, bytes, owned4 = false) {
+    const whole = owned4 && 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);
@@ -14715,7 +15033,7 @@ function created2(ino, kind, mode, from, owner) {
     gid: owner?.gid ?? from?.gid ?? 0
   };
 }
-function owned2(node, change) {
+function owned3(node, change) {
   if (change.uid !== void 0) node.uid = change.uid;
   if (change.gid !== void 0) node.gid = change.gid;
 }
@@ -14886,7 +15204,7 @@ function tmpfs() {
         node.mtime = Date.now();
       }
       if (change.mtime !== void 0) node.mtime = change.mtime;
-      owned2(node, change);
+      owned3(node, change);
     },
     async statfs() {
       return { bsize: 4096, blocks: 262144, bfree: 262144 };
@@ -15578,6 +15896,10 @@ var Launcher = class {
   fs;
   processFs;
   prefixes;
+  writerTags;
+  unguardedRoot;
+  writers;
+  unlinkOwnerOption;
   base;
   createWorker;
   modulesDir;
@@ -15635,12 +15957,16 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  rootFs;
+  fileWatches;
   nextPid = 1e3;
   boot = Date.now();
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
+    this.rootFs = options.fs;
     this.dac = this.usersMode === "off" ? void 0 : new Dac(this.usersMode, options.onDenial);
+    if (this.dac) this.dac.tagOf = (pid) => this.tagOf(pid);
     this.sealed = new SealedBroker(
       options.sealed,
       this.usersMode,
@@ -15691,7 +16017,7 @@ var Launcher = class {
     this.nodes = new VfsNodes(fs, (path) => this.released(path));
     this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
-    const holders = [this.held, [this.nodes]];
+    const holders = [this.held, this.openFiles];
     this.unlinked = new UnlinkedKeeper(
       fs,
       { [Symbol.iterator]: () => holders.flatMap((set2) => [...set2]).values() },
@@ -15704,7 +16030,12 @@ var Launcher = class {
       }
     );
     this.fs = this.unlinked.wrap(keepingOpen(fs, this.nodes));
-    if (options.protect?.writer) throw new Error(PROTECT_WRITER);
+    this.writerTags = writerTags(options.protect);
+    this.unlinkOwnerOption = options.unlinkOwner;
+    if (this.writerTags.size > 0 && options.fs.protect && !options.fs.unguarded) {
+      throw new TypeError("protect.writers needs a root file system with an unguarded view");
+    }
+    this.unguardedRoot = options.fs.unguarded?.() ?? options.fs;
     this.prefixes = protectedPrefixes(options.protect?.paths ?? []);
     this.processFs = this.prefixes.length > 0 ? new ProtectedFs(this.prefixes).view(this.fs) : this.fs;
     options.fs.protect?.(this.prefixes);
@@ -15890,7 +16221,7 @@ var Launcher = class {
   async mayExec(cred, req, planned) {
     const { dac } = this;
     if (!dac) return;
-    const g = { fs: this.fs, cred, pid: req.pid, dac };
+    const g = { fs: this.fs, cred, pid: req.pid, dac, tag: req.tag };
     const byPath = (file) => file.includes("/") && !COMMAND2.test(file);
     if (byPath(req.file)) {
       const path = this.fs.resolvePath(req.cwd, req.file);
@@ -16028,6 +16359,7 @@ var Launcher = class {
       throw fsError("ESRCH", `no process group ${req.pgid}`);
     }
     const pid = this.nextPid++;
+    const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
     const decided = req.decided ?? Promise.resolve(true);
     const count = (byParent) => {
@@ -16058,8 +16390,8 @@ var Launcher = class {
       env: req.env,
       cwd: req.cwd,
       fds: req.fds,
-      fs: this.processFs,
-      ...this.prefixes.length > 0 ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
+      fs: stack.fs,
+      ...this.prefixes.length > 0 && !stack.writer ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
       createWorker: this.createWorker,
       onError: req.report,
       spawner: this.spawner(pid, req.report),
@@ -16074,9 +16406,9 @@ var Launcher = class {
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       openFiles: this.openFiles,
-      nodes: this.nodes,
+      nodes: stack.nodes,
       held: this.held,
-      unlinkGate: this.unlinked.gate,
+      unlinkGate: stack.unlinked.gate,
       statfs: (path) => this.mounts.statfs(path),
       mounts: () => this.mounts.list(),
       mount: (call, signal) => this.processMount(pid, call, signal),
@@ -16377,6 +16709,7 @@ var Launcher = class {
   released(path) {
     const at = normalizePath(path);
     this.unlinked.closed(at);
+    this.writers?.unlinked.closed(at);
     const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open) void this.mounts.commit(at).catch(() => void 0);
   }
@@ -16393,6 +16726,13 @@ var Launcher = class {
   kill(pid, sig, sender, from) {
     const session = from === void 0 ? void 0 : this.jobs.sidOf(from);
     const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from;
+    if (pid === -1) {
+      const sender2 = from === void 0 ? void 0 : this.imageOf(from);
+      return this.killAll(
+        sig,
+        (member) => this.imageOf(member) !== sender2 && may(this.imageOf(member))
+      );
+    }
     if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)));
     const handle = this.processes.get(pid);
     if (!handle) return false;
@@ -16400,6 +16740,15 @@ var Launcher = class {
     if (sig !== 0) handle.signal(sig);
     return true;
   }
+  killAll(sig, may) {
+    let any = false;
+    for (const [pid, handle] of [...this.processes]) {
+      if (pid === 1 || !may(pid)) continue;
+      any = true;
+      if (sig !== 0) handle.signal(sig);
+    }
+    return any;
+  }
   async driver(type, spec) {
     if (type === "fsa") return this.fsaDriver(spec);
     if (type === "hostfs") {
@@ -16489,6 +16838,16 @@ var Launcher = class {
       }
     };
   }
+  attest(path) {
+    return attest(this.rootFs, path, {
+      users: this.usersMode,
+      mounts: this.mounts.list().map((entry) => entry.target).filter((target) => this.mounts.mounted(target) !== void 0)
+    });
+  }
+  watchFiles(paths, notify) {
+    this.fileWatches ??= new FileWatches(this.watchers, this.rootFs);
+    return this.fileWatches.watch(paths, notify);
+  }
   async mount(spec) {
     this.guardMount(spec.target);
     const fsa = spec.type === "fsa" && !spec.source.startsWith("fsa:");
@@ -16669,21 +17028,57 @@ var Launcher = class {
       ...account.umask !== void 0 ? { umask: account.umask } : {}
     };
   }
-  async starting(argv, dir, account) {
+  fsFor(tag) {
+    return this.stackFor(tag).fs;
+  }
+  isWriter(tag) {
+    return tag !== void 0 && this.prefixes.length > 0 && this.writerTags.has(tag);
+  }
+  stackFor(tag) {
+    if (!this.isWriter(tag)) {
+      return { fs: this.processFs, nodes: this.nodes, unlinked: this.unlinked, writer: false };
+    }
+    this.writers ??= this.writerStack();
+    return this.writers;
+  }
+  writerStack() {
+    const fs = withCommandDirs(
+      this.watchers.wrap(this.mounts.wrap(this.unguardedRoot)),
+      async () => new Set((await this.commands()).keys()),
+      (dir) => this.userCommandDir(dir),
+      this.owners
+    );
+    const nodes = new VfsNodes(fs, (path) => this.released(path));
+    nodes.keepsOnDisk = true;
+    this.openFiles.add(nodes);
+    const unlinked = new UnlinkedKeeper(
+      fs,
+      { [Symbol.iterator]: () => [this.held, this.openFiles].flatMap((set2) => [...set2]).values() },
+      (path) => this.mountRoot(path),
+      {
+        locks: webLocks(),
+        busy: (path) => [...this.openFiles].some((open) => open.holds(path)),
+        owner: this.unlinkOwnerOption,
+        ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
+      }
+    );
+    return { fs: unlinked.wrap(keepingOpen(fs, nodes)), nodes, unlinked, writer: true };
+  }
+  async starting(argv, dir, account, tag) {
     this.resetCatalogs();
     const scope = account.uid === 0 ? "" : pnpmHomeOf(account, this.pnpmHome);
     const start2 = dir ?? "/";
     const cwd = await physicalPathAsync(this.base, start2.startsWith("/") ? start2 : `/${start2}`);
     const [file = ""] = argv;
-    if (!await this.base.exists(cwd)) await this.processFs.mkdir(cwd, { recursive: true });
+    if (!await this.base.exists(cwd)) await this.stackFor(tag).fs.mkdir(cwd, { recursive: true });
     const planned = await this.plan(file, argv, cwd, scope);
-    await this.mayExec(credOf(account), { file, cwd, pid: 0 }, planned);
+    await this.mayExec(credOf(account), { file, cwd, pid: 0, tag }, planned);
     return { cwd, file, planned };
   }
   async openTerminal(argv, options) {
     tagOption(options.tag);
     const { account, tty: ttyGroup } = await this.terminalAccount(options.user);
-    const { cwd, file, planned } = await this.starting(argv, options.cwd, account);
+    const { cwd, file, planned } = await this.starting(argv, options.cwd, account, options.tag);
     if (!planned) throw new Error(`${file}: command not found`);
     let leader = 0;
     const tty = new KernelTty(
@@ -16734,7 +17129,7 @@ var Launcher = class {
   async run(argv, options = {}) {
     tagOption(options.tag);
     const account = await this.account(options.user);
-    const { cwd, file, planned } = await this.starting(argv, options.cwd, account);
+    const { cwd, file, planned } = await this.starting(argv, options.cwd, account, options.tag);
     const env = this.environment(cwd, options.env, account);
     const out = [];
     const err = [];
@@ -16893,9 +17288,31 @@ var USERS_OPS = /* @__PURE__ */ new Set([
   "groups-add-member",
   "groups-remove-member"
 ]);
+var ATTEST_OPS = /* @__PURE__ */ new Set(["attest", "watch-files", "unwatch-files"]);
+function isAttestRequest(req) {
+  return ATTEST_OPS.has(req.op);
+}
 function isUsersRequest(req) {
   return USERS_OPS.has(req.op);
 }
+function transferOf2(req, result) {
+  if (result instanceof MessagePort) return [result];
+  if (req.op === "attest") return [result.bytes.buffer];
+  return void 0;
+}
+function attestOps(port) {
+  const watches = /* @__PURE__ */ new Map();
+  return async (l, req) => {
+    if (req.op === "attest") return l.attest(req.path);
+    if (req.op === "unwatch-files") {
+      watches.get(req.watch)?.();
+      return watches.delete(req.watch);
+    }
+    const notify = (path) => port.postMessage({ fileChanged: { watch: req.id, path } });
+    watches.set(req.id, await l.watchFiles(req.paths, notify));
+    return req.id;
+  };
+}
 function failure(err) {
   const code = err?.code;
   return {
@@ -16916,7 +17333,7 @@ function hostOptions(req, port, sealed) {
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
     ...req.users !== void 0 ? { users: req.users } : {},
     ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {},
-    ...req.protect ? { protect: { paths: [...req.protect.paths] } } : {},
+    ...req.protect ? { protect: protectInit(req.protect) } : {},
     ...req.sealed ? { sealed } : {}
   };
 }
@@ -17034,8 +17451,10 @@ function serveKernel(port, deps) {
     if (req.op === "insert") return l.insert(req.target, req.handle, req.source);
     return l.mounts.list();
   }
+  const attestOp = attestOps(port);
   async function handle(req) {
     if (req.op === "init") return init(req);
+    if (isAttestRequest(req)) return attestOp(await ready2(), req);
     if (req.op === "open-terminal") return terminal(req);
     if (req.op === "connect") return connect(req.user, req.tag);
     if (isUsersRequest(req)) return usersOp(await ready2(), req);
@@ -17084,7 +17503,7 @@ function serveKernel(port, deps) {
     if (answered(event.data, remote, uplink, approvals)) return;
     const req = event.data;
     handle(req).then(
-      (result) => reply(req.id, { result }, result instanceof MessagePort ? [result] : void 0),
+      (result) => reply(req.id, { result }, transferOf2(req, result)),
       (err) => reply(req.id, failure(err))
     );
   });