@ai-ecoverse/slicc-kernel 1.71.0 → 1.72.0

package/dist/node.js

@@ -371,6 +371,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;
@@ -379,7 +380,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 {
@@ -397,7 +400,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}`})`
     );
   }
 };
@@ -413,7 +416,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) {
@@ -2595,9 +2599,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);
@@ -2701,6 +2705,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();
@@ -2810,10 +2815,10 @@ function serveClient(port, host) {
         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 fsCall(l.processFs, req.method, req.args, ownerFor(l, self), guard2(l));
       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":
@@ -3174,6 +3179,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;
@@ -3297,6 +3417,7 @@ var OpfsFs = class {
   dirs = new PathMap();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
+  remote;
   ranged;
   owners = false;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
@@ -3304,9 +3425,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?.();
     }
@@ -3315,6 +3442,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);
   }
@@ -3666,15 +3803,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 }),
@@ -3687,9 +3827,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) {
@@ -3738,6 +3881,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);
@@ -3759,12 +3903,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])];
       })
     );
   }
@@ -3828,7 +3972,14 @@ var OpfsFs = class {
   links() {
     return false;
   }
-  async link(from) {
+  async link(from, to, follow2) {
+    await (follow2 ? this.stat(from) : this.lstat(from));
+    if (!(await this.stat(parentOf4(to))).isDirectory) throw fsError("ENOTDIR", to);
+    if (await this.lstat(to).then(
+      () => true,
+      () => false
+    ))
+      throw fsError("EEXIST", to);
     throw fsError("EPERM", `${from}: this file system has no hard links`);
   }
   async rename(from, to) {
@@ -5266,6 +5417,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;
@@ -5304,7 +5585,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 };
@@ -5318,17 +5599,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));
@@ -5455,11 +5736,11 @@ async function physicalPathAsync(fs, path) {
 
 // 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 {
@@ -7178,7 +7459,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);
@@ -7233,7 +7514,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);
   }
@@ -11436,6 +11717,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-sudo",
   "proc-run",
   "proc-exit",
+  "proc-kill-self",
   "proc-fork",
   "proc-kill",
   "thread-kill",
@@ -11563,6 +11845,20 @@ var WasmProcess = class {
     else this.adoptExec(pid);
     return pid;
   }
+  async killSelf(sig, target, probe2) {
+    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 (probe2) 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,
@@ -12160,6 +12456,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": {
@@ -12594,6 +12892,7 @@ function processOptions(opts, header4, 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(header4, SAB_I_SIGNALS) } : {}
   };
 }
@@ -12627,7 +12926,10 @@ function spawnWasmProcess(opts) {
       {
         raise: (sig) => signal(sig),
         threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.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
     )
@@ -14535,8 +14837,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);
@@ -14586,7 +14888,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;
 }
@@ -14757,7 +15059,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 };
@@ -15506,12 +15808,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,
@@ -15761,7 +16067,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);
@@ -16264,6 +16570,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;
@@ -16271,6 +16584,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") {
@@ -16360,6 +16682,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:");
@@ -16540,7 +16872,7 @@ var Launcher = class {
       ...account.umask !== void 0 ? { umask: account.umask } : {}
     };
   }
-  async starting(argv, dir, account) {
+  async starting(argv, dir, account, tag) {
     this.resetCatalogs();
     const scope = account.uid === 0 ? "" : pnpmHomeOf(account, this.pnpmHome);
     const start2 = dir ?? "/";
@@ -16548,13 +16880,13 @@ var Launcher = class {
     const [file = ""] = argv;
     if (!await this.base.exists(cwd)) await this.processFs.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(
@@ -16605,7 +16937,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 = [];