@ai-ecoverse/slicc-kernel 1.86.0 → 1.88.0

package/dist/kernel-worker.js

@@ -97,8 +97,8 @@ var MemoryMeta = class {
   async get(paths) {
     return paths.map((path) => this.entries.get(path));
   }
-  async fresh(path) {
-    return this.entries.get(path);
+  async fresh(paths) {
+    return this.get(paths);
   }
   async update(path, change) {
     this.set(path, change(this.entries.get(path)));
@@ -196,15 +196,13 @@ var IndexedDbMeta = class {
     }
     return paths.map((path) => this.cache.get(path) ?? void 0);
   }
-  async fresh(path) {
+  async fresh(paths) {
     const [transaction, store] = this.transaction("readonly");
-    const request2 = store.get(path);
-    let entry;
-    request2.onsuccess = () => {
-      entry = request2.result ?? void 0;
-    };
-    await settle(transaction, () => void 0);
-    return entry;
+    const requests = paths.map((path) => store.get(path));
+    return settle(
+      transaction,
+      () => requests.map((request2) => request2.result ?? void 0)
+    );
   }
   async update(path, change) {
     this.settleRemoves();
@@ -1020,8 +1018,25 @@ var OpfsFs = class {
   }
   counted = [];
   async stamp(path) {
-    const entry = this.meta.fresh ? await this.meta.fresh(path) : (await this.meta.get([path]))[0];
-    return String(entry?.writes ?? 0);
+    const paths = [path, "/"];
+    const [entry, root] = this.meta.fresh ? await this.meta.fresh(paths) : await this.meta.get(paths);
+    return `${entry?.writes ?? 0}:${root?.epoch ?? 0}`;
+  }
+  async epoch() {
+    await this.meta.update("/", (entry) => ({
+      ...entry,
+      path: "/",
+      epoch: (entry?.epoch ?? 0) + 1
+    }));
+  }
+  async entering(path, change) {
+    if (!isProtected(this.counted, path) && !holdsProtected(this.counted, path)) return change();
+    await this.epoch();
+    try {
+      await change();
+    } finally {
+      await this.epoch();
+    }
   }
   async counting(target) {
     if (!isProtected(this.counted, target)) return;
@@ -1092,9 +1107,9 @@ var OpfsFs = class {
     if (fields) await this.meta.update(path, (entry) => ({ ...entry, path, ...fields }));
   }
   guarded = [];
-  protect(prefixes2) {
+  protect(prefixes2, versions = false) {
     this.guarded = prefixes2;
-    this.counted = prefixes2;
+    this.counted = versions ? prefixes2 : [];
   }
   unguarded() {
     return Object.create(this, { guarded: { value: [] } });
@@ -1674,6 +1689,9 @@ var OpfsFs = class {
     const parent = await this.locate(parentOf3(to), true);
     const destination = resolvePath(parent.path, baseOf(to));
     this.refuse(destination, true);
+    await this.entering(destination, () => this.moveTo(source, parent, destination, to));
+  }
+  async moveTo(source, parent, destination, to) {
     const sourceStat = await this.describe(source);
     if (sourceStat.isDirectory && within2(destination, source.path)) throw fsError("EINVAL", to);
     const target = await this.locate(destination, false).catch((err) => {
@@ -1781,15 +1799,18 @@ var OpfsFs = class {
     }
     const now = Date.now();
     const fields = await this.newFields(at, owner && { uid: owner.uid, gid: owner.gid }, false);
-    await this.meta.update(at, () => ({
-      path: at,
-      link: target,
-      dir: parent.path,
-      ino: inodeOf(at),
-      mtimeMs: now,
-      ctimeMs: now,
-      ...fields
-    }));
+    await this.entering(
+      at,
+      () => this.meta.update(at, () => ({
+        path: at,
+        link: target,
+        dir: parent.path,
+        ino: inodeOf(at),
+        mtimeMs: now,
+        ctimeMs: now,
+        ...fields
+      }))
+    );
     this.touch(parent.path);
   }
   async realpath(path, follow2) {
@@ -2580,6 +2601,10 @@ var KernelError = class extends Error {
     if (detail !== void 0) this.detail = detail;
   }
 };
+function openAccess(flags2) {
+  const mode = flags2 & 3;
+  return mode === 0 ? "read" : mode === 1 ? "write" : "both";
+}
 function pollFile(file) {
   return file.poll?.() ?? { readable: !!file.read, writable: !!file.write, hangup: false };
 }
@@ -7127,8 +7152,12 @@ function closeAll(entry) {
 
 // src/commands.ts
 var NAME2 = /^[A-Za-z0-9._+-]+$/;
+var COMMAND_NAME = /^[^/\s\p{Cc}]+$/u;
 var ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
 var PACKAGE = /\$\{package\}/g;
+function commandName(name2) {
+  return COMMAND_NAME.test(name2) && name2.isWellFormed() && name2 !== "." && name2 !== "..";
+}
 function inside(pkg, rel2) {
   if (typeof rel2 !== "string" || rel2 === "") return void 0;
   const clean = rel2.replace(/^\.\//, "");
@@ -7218,7 +7247,7 @@ function commandsOf(pkg, manifest) {
   const shared = envOf(pkg, slicc.env);
   const out = [];
   for (const [name2, raw] of Object.entries(entries)) {
-    if (!NAME2.test(name2) || name2 === "." || name2 === ".." || !raw || typeof raw !== "object") {
+    if (!commandName(name2) || !raw || typeof raw !== "object") {
       continue;
     }
     const command = commandOf(pkg, name2, raw, packageAbi, shared);
@@ -7270,18 +7299,86 @@ async function packagesIn(fs, roots) {
     dirs.push(...await packages(fs, root));
   return dirs;
 }
-async function scanCommands(fs, modules) {
-  const found = /* @__PURE__ */ new Map();
-  for (const pkg of await packagesIn(fs, modules)) {
-    let manifest;
-    try {
-      manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
-    } catch {
-      continue;
+function binEntries(manifest) {
+  const { bin, name: name2 } = manifest;
+  if (typeof bin === "string") {
+    return typeof name2 === "string" ? [[name2.slice(name2.lastIndexOf("/") + 1), bin]] : [];
+  }
+  return bin && typeof bin === "object" ? Object.entries(bin) : [];
+}
+var MAX_HOPS = 40;
+function physicalResolver(fs) {
+  const known = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  let hops = 0;
+  const step = async (path) => {
+    if (path === "/") return { path, file: false };
+    const slash = path.lastIndexOf("/");
+    const parent = await resolve2(path.slice(0, slash) || "/");
+    if (parent === void 0) return void 0;
+    const at = resolvePath(parent.path, path.slice(slash + 1));
+    const st = await fs.lstat(at).catch(() => void 0);
+    if (!st?.isSymbolicLink) return st ? { path: at, file: st.isFile === true } : void 0;
+    const target = await fs.readlink(at).catch(() => void 0);
+    if (target === void 0 || ++hops > MAX_HOPS) return void 0;
+    return resolve2(resolvePath(parent.path, target));
+  };
+  const resolve2 = (path) => {
+    if (pending.has(path)) return Promise.resolve(void 0);
+    let found = known.get(path);
+    if (!found) {
+      pending.add(path);
+      found = step(path).finally(() => pending.delete(path));
+      known.set(path, found);
     }
-    for (const command of commandsOf(pkg, manifest)) {
-      if (!found.has(command.name))
-        found.set(command.name, await withPackagePaths(fs, pkg, command));
+    return found;
+  };
+  return (path) => {
+    hops = 0;
+    return resolve2(path);
+  };
+}
+async function binCommandsOf(physical, pkg, manifest, taken) {
+  const entries = binEntries(manifest);
+  if (entries.length === 0) return [];
+  const home = (await physical(pkg))?.path;
+  const out = [];
+  for (const [name2, rel2] of entries) {
+    if (taken.has(name2) || !commandName(name2)) continue;
+    const script = inside(pkg, rel2);
+    if (!script) continue;
+    const real = await physical(script);
+    if (!real?.file || !real.path.startsWith(`${home}/`)) continue;
+    out.push({
+      name: name2,
+      abi: "emscripten",
+      glue: script,
+      wasm: script,
+      argv0: name2,
+      script,
+      bin: true
+    });
+  }
+  return out;
+}
+async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY) {
+  const found = /* @__PURE__ */ new Map();
+  const physical = physicalResolver(fs);
+  for (const [index, root] of (typeof modules === "string" ? [modules] : modules).entries()) {
+    for (const pkg of await packages(fs, root)) {
+      let manifest;
+      try {
+        manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
+      } catch {
+        continue;
+      }
+      const own = commandsOf(pkg, manifest);
+      const named = new Set(own.map((command) => command.name));
+      const bins = index >= binsFrom ? await binCommandsOf(physical, pkg, manifest, named) : [];
+      for (const command of [...own, ...bins]) {
+        if (!found.has(command.name))
+          found.set(command.name, await withPackagePaths(fs, pkg, command));
+      }
     }
   }
   if (!found.has("sh") && found.has("bash")) {
@@ -7740,7 +7837,7 @@ var FreshModules = class {
 };
 
 // src/fs/physical-path.ts
-var MAX_HOPS = 40;
+var MAX_HOPS2 = 40;
 function start(path) {
   return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
 }
@@ -7765,7 +7862,7 @@ function rest(walk2, part) {
   return lexical(`/${[...walk2.done, part, ...walk2.todo].join("/")}`);
 }
 function follow(walk2, target) {
-  if (++walk2.hops > MAX_HOPS) return false;
+  if (++walk2.hops > MAX_HOPS2) return false;
   if (target.startsWith("/")) walk2.done.length = 0;
   walk2.todo = [...target.split("/").filter((p) => p !== ""), ...walk2.todo];
   return true;
@@ -9971,7 +10068,7 @@ async function dispatchOne(entry, req) {
 }
 
 // src/realm/sync-sab-wire.ts
-var SAB_HEADER_I32 = 16;
+var SAB_HEADER_I32 = 18;
 var SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
 var SAB_CLOCK_I64 = 3;
 var SAB_HEADER_BYTES = SAB_CLOCK_OFFSET + SAB_CLOCK_I64 * 8;
@@ -9991,6 +10088,7 @@ var SAB_I_OFFSET_HI = 12;
 var SAB_I_KILLED = 13;
 var SAB_I_ASYNC = 14;
 var SAB_I_STOP = 15;
+var SAB_I_BLOCKED = 16;
 var U32 = 2 ** 32;
 function storeU53(header3, lo, hi, value) {
   Atomics.store(header3, hi, Math.floor(value / U32));
@@ -10516,12 +10614,32 @@ function mountTable(mounts = []) {
 `;
 }
 
+// src/version.ts
+var KERNEL_VERSION = true ? "1.88.0" : "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
+`;
+}
+
 // src/process/procfs.ts
 var HZ = 100;
 var KIB = 1024;
 var FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
 var PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
-var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime", "version"];
+var SYS_TREE = {
+  kernel: { osrelease: `${OS_RELEASE}
+`, ostype: "Linux\n" }
+};
+function sysEntry(parts2) {
+  let at = SYS_TREE;
+  for (const part of parts2) {
+    if (typeof at !== "object" || !Object.hasOwn(at, part)) return void 0;
+    at = at[part];
+  }
+  return at;
+}
 function commOf(info) {
   const name2 = info.argv[0] ?? "";
   return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
@@ -10609,7 +10727,7 @@ function pidStatus(info) {
     "SigQ:	0/0",
     "SigPnd:	0000000000000000",
     "ShdPnd:	0000000000000000",
-    "SigBlk:	0000000000000000",
+    `SigBlk:	${sigMask(info.sigBlk)}`,
     `SigIgn:	${sigMask(info.sigIgn)}`,
     `SigCgt:	${sigMask(info.sigCgt)}`,
     ""
@@ -10645,6 +10763,7 @@ function memoryInfo(source, used = 0) {
   ].map(([key, value]) => `${`${key}:`.padEnd(16)}${value.padStart(12)}`).concat("").join("\n");
 }
 function systemFile(name2, listing, now, memory) {
+  if (name2 === "version") return procVersion();
   const up = Math.max(0, now - listing.boot) / 1e3;
   if (name2 === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
 `;
@@ -10735,11 +10854,17 @@ var ProcTree = class {
         names: () => [
           ...SYSTEM_NAMES,
           "mounts",
+          "sys",
           "self",
           ...this.listing().processes.map((p) => String(p.pid))
         ]
       };
     }
+    if (top === "sys") {
+      const entry = sysEntry(parts2.slice(1));
+      if (typeof entry === "string") return { kind: "file", content: () => entry };
+      return entry && { kind: "dir", names: () => Object.keys(entry) };
+    }
     if (top === "self") {
       return leaf === void 0 ? { kind: "link", target: String(this.pid) } : void 0;
     }
@@ -10817,7 +10942,7 @@ var ProcTree = class {
     }
   }
 };
-var MAX_HOPS2 = 40;
+var MAX_HOPS3 = 40;
 function* procWalk(path, follow2) {
   let done4 = [];
   let todo = path.split("/").filter((part) => part !== "");
@@ -10836,7 +10961,7 @@ function* procWalk(path, follow2) {
     if (!follow2 && todo.length === 0) return void 0;
     const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
     if (typeof target === "string") {
-      if (++hops > MAX_HOPS2) return void 0;
+      if (++hops > MAX_HOPS3) return void 0;
       [done4, todo] = throughLink(target, done4, todo);
     } else {
       broken ??= refusalOf(target);
@@ -12395,11 +12520,12 @@ var VfsNodes = class {
   byId = /* @__PURE__ */ new Map();
   keepsOnDisk = false;
   fs;
-  entries = /* @__PURE__ */ new Map();
+  entries;
   onClosed;
-  constructor(fs, onClosed) {
+  constructor(fs, onClosed, entries = /* @__PURE__ */ new Map()) {
     this.fs = fs;
     this.onClosed = onClosed;
+    this.entries = entries;
   }
   async onEntry(path, op) {
     const key = await this.entryKey(path);
@@ -12889,6 +13015,7 @@ var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
   exited = false;
   children;
+  deathSignals = /* @__PURE__ */ new Map();
   caught = 0;
   ignored = 0;
   inherited = 0;
@@ -12923,7 +13050,10 @@ var WasmProcess = class {
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
     if (!options.nodes) options.openFiles?.add(this.nodes);
     this.children.onChildState = () => this.signal(SIG.CHLD);
-    this.children.onReap = options.onReap;
+    this.children.onReap = (pid2) => {
+      this.deathSignals.delete(pid2);
+      options.onReap?.(pid2);
+    };
   }
   ignores(bit) {
     return (this.signalMasks().ignored & bit) !== 0;
@@ -12951,6 +13081,10 @@ var WasmProcess = class {
     if (sig === SIG.STOP) return this.stop(sig);
     const bit = sigbit(sig);
     if (this.ignores(bit)) return "ignore";
+    if (((this.options.blockedBits?.() ?? 0) & bit) !== 0) {
+      this.options.onPending?.(sig);
+      return "deliver";
+    }
     if (!(this.caught & bit)) {
       const action = defaultAction(sig);
       return action === "stop" ? this.stop(sig) : action;
@@ -12967,16 +13101,27 @@ var WasmProcess = class {
     return "deliver";
   }
   async spawn(req) {
-    const { file, argv, argv0, env, cwd, stdio, inherit: inherit2, exec, pgid, session } = req;
+    const { file, argv, argv0, env, cwd, stdio, inherit: inherit2, exec, pgid, session, deathSignal } = req;
+    if (deathSignal !== void 0 && (exec || !isSignal(deathSignal))) {
+      throw new KernelError("EINVAL");
+    }
     const group = { ...pgid !== void 0 ? { pgid } : {}, ...session ? { session } : {} };
     const named = argv0 !== void 0 ? { argv0 } : {};
     const spawned = { file, argv, ...named, env, cwd, ...group, ...exec ? { exec } : {} };
     const pid = await this.children.spawn(spawned, stdio, inherit2);
+    if (deathSignal !== void 0) this.onDeath(pgid === 0 || session ? -pid : pid, deathSignal);
     if (!exec) return pid;
     if (this.killed) void Promise.allSettled([this.options.kill?.(pid, SIG.KILL)]);
     else this.adoptExec(pid);
     return pid;
   }
+  onDeath(target, sig) {
+    if (this.exited) this.sendDeath(target, sig);
+    else this.deathSignals.set(target, sig);
+  }
+  sendDeath(target, sig) {
+    void Promise.resolve(this.options.kill?.(target, sig)).catch(() => void 0);
+  }
   async killSelf(sig, target, probe) {
     if (!this.options.exitSignal) throw new KernelError("ENOSYS");
     if (!isSignal(sig) || defaultAction(sig) !== "terminate") throw new KernelError("EINVAL");
@@ -13255,17 +13400,15 @@ var WasmProcess = class {
     const file = tty.file();
     return this.fds.install(this.options.outputFilter?.(file) ?? file, 3);
   }
-  openSealed() {
+  openSealed(flags2) {
     const broker = this.options.sealed;
     if (!broker) throw new KernelError("ENOENT");
-    return this.fds.install(broker.open(), 3);
+    return this.fds.install(broker.open(openAccess(flags2)), 3);
   }
   async openClipboard(flags2) {
     const broker = this.options.clipboard;
     if (!broker) throw new KernelError("ENOENT");
-    const mode = flags2 & WRITE_ACCESS;
-    const access2 = mode === 0 ? "read" : mode === 1 ? "write" : "both";
-    const file = broker.open(access2, await this.clipboardStamp());
+    const file = broker.open(openAccess(flags2), await this.clipboardStamp());
     return this.fds.install(this.options.outputFilter?.(file) ?? file, 3);
   }
   async clipboardStamp() {
@@ -13424,7 +13567,7 @@ var WasmProcess = class {
       case "fd-tty-names":
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-open-sealed":
-        return { ok: true, kind: "json", json: this.openSealed() };
+        return { ok: true, kind: "json", json: this.openSealed(req.flags) };
       case "fd-open-clipboard":
         return { ok: true, kind: "json", json: await this.openClipboard(req.flags) };
       case "fd-tty-owner":
@@ -13877,6 +14020,8 @@ var WasmProcess = class {
     this.interrupt.abort();
     this.options.locks?.release(this.pid);
     this.asyncOps.close();
+    for (const [target, sig] of this.deathSignals) this.sendDeath(target, sig);
+    this.deathSignals.clear();
     for (const pid of this.children.pids()) this.options.onReap?.(pid);
     await this.stampClipboards();
     await this.fds.closeAll();
@@ -13956,19 +14101,25 @@ var Dying = class {
   }
 };
 function killThread(thread, caught, sig) {
-  if (!thread || (caught & sigbit(sig)) === 0) return false;
+  if (!thread) return false;
+  const held = (Atomics.load(thread.header, SAB_I_BLOCKED) & sigbit(sig)) !== 0;
+  if (!held && (caught & sigbit(sig)) === 0) return false;
   Atomics.or(thread.header, SAB_I_SIGNALS, sigbit(sig));
+  if (held) return true;
   Atomics.notify(thread.header, SAB_I_SIGNALS);
   const blocked = thread.interrupt;
   thread.interrupt = new AbortController();
   blocked.abort();
   return true;
 }
+function unblocked(header3) {
+  return Atomics.load(header3, SAB_I_SIGNALS) & ~Atomics.load(header3, SAB_I_BLOCKED);
+}
 function threadSignalsOf(sab) {
   return { header: new Int32Array(sab, 0, SAB_HEADER_I32), interrupt: new AbortController() };
 }
 function threadCancel(thread) {
-  return Atomics.load(thread.header, SAB_I_SIGNALS) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
+  return unblocked(thread.header) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
 }
 function notifiers(header3) {
   return {
@@ -14093,15 +14244,16 @@ function processOptions(opts, header3, hooks, created3) {
     resolver: opts.resolver,
     ...notifiers(header3),
     onTimer: (which) => void Atomics.or(header3, SAB_I_TIMERS, 1 << which),
-    hasPending: () => Atomics.load(header3, SAB_I_SIGNALS) !== 0 || Atomics.load(header3, SAB_I_TIMERS) !== 0,
+    hasPending: () => unblocked(header3) !== 0 || Atomics.load(header3, SAB_I_TIMERS) !== 0,
     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) } : {}
+    ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header3, SAB_I_SIGNALS) } : {},
+    ...opts.program.abi === "wasi" ? { blockedBits: () => Atomics.load(header3, SAB_I_BLOCKED) } : {}
   };
 }
-function threadInit(opts, program, sab, cred, thread) {
+function threadInit(opts, program, sab, cred, thread, main) {
   return {
     type: WASM_THREAD_INIT,
     pid: opts.shownPid ?? opts.pid,
@@ -14114,12 +14266,15 @@ function threadInit(opts, program, sab, cred, thread) {
     cred: copyCred(cred),
     owners: opts.owners === true,
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
-    thread
+    thread,
+    signals: main
   };
 }
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
+  if (opts.blocked && opts.program.abi === "wasi")
+    Atomics.store(header3, SAB_I_BLOCKED, opts.blocked);
   const threadSignals = /* @__PURE__ */ new Map();
   const created3 = new Created();
   const process = new WasmProcess(
@@ -14220,6 +14375,7 @@ function spawnWasmProcess(opts) {
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
     const tsignals = threadSignalsOf(tsab);
+    if (thread.blocked) Atomics.store(tsignals.header, SAB_I_BLOCKED, thread.blocked);
     threadSignals.set(thread.tid, tsignals);
     const tdispatch = (req) => dying.serving(
       () => isWasmSyscall(req) ? process.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
@@ -14241,7 +14397,7 @@ function spawnWasmProcess(opts) {
       tresponder.dispose();
       tw.terminate();
     });
-    tw.postMessage(threadInit(opts, program, tsab, process.cred, thread));
+    tw.postMessage(threadInit(opts, program, tsab, process.cred, thread, sab));
   };
   worker.postMessage(
     processInit(opts, sab, process.umask, copyCred(process.cred), lane?.lane),
@@ -14263,6 +14419,7 @@ function spawnWasmProcess(opts) {
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header3, SAB_I_MEMORY) * 65536,
     ignoredSignals: (fork) => process.inheritable(fork),
+    blockedSignals: () => opts.program.abi === "wasi" ? Atomics.load(header3, SAB_I_BLOCKED) : 0,
     signalMasks: () => process.signalMasks(),
     umask: () => process.umask,
     cred: () => copyCred(process.cred),
@@ -15143,14 +15300,19 @@ var SealedChannel = class {
   offset = 0;
   inflight;
   broker;
-  constructor(broker) {
+  access;
+  constructor(broker, access2) {
     this.broker = broker;
+    this.access = access2;
   }
   send(bytes, caller, gone) {
+    if (this.access === "read") {
+      bytes.fill(0);
+      throw new KernelError("EBADF");
+    }
     const length2 = bytes.length;
     const fields = parseSealed(bytes);
-    this.reply = void 0;
-    this.offset = 0;
+    this.drop();
     this.inflight?.control.abort("replaced");
     const control = new AbortController();
     const withdraw = () => control.abort("withdrawn");
@@ -15186,15 +15348,18 @@ var SealedChannel = class {
     if (!signal.aborted) return reply;
     return signal.reason === "timeout" ? errorReply("ETIMEDOUT", "the vault did not answer within 10 s") : void 0;
   }
+  drop() {
+    this.reply?.fill(0);
+    this.reply = void 0;
+    this.offset = 0;
+  }
   async read(max, signal) {
+    if (this.access === "write") throw new KernelError("EBADF");
     for (; ; ) {
       if (this.reply) {
         const out = this.reply.slice(this.offset, this.offset + max);
         this.offset += out.length;
-        if (this.offset >= this.reply.length) {
-          this.reply = void 0;
-          this.offset = 0;
-        }
+        if (this.offset >= this.reply.length) this.drop();
         return out;
       }
       const flight = this.inflight;
@@ -15227,7 +15392,7 @@ var SealedChannel = class {
   close() {
     this.inflight?.control.abort("withdrawn");
     this.inflight = void 0;
-    this.reply = void 0;
+    this.drop();
   }
 };
 function swapOf(reply) {
@@ -15284,12 +15449,14 @@ var SealedBroker = class {
       control.abort("done");
     }
   }
-  open() {
-    const channel = new SealedChannel(this);
+  open(access2 = "both") {
+    const channel = new SealedChannel(this, access2);
     return new OpenFile({
-      read: (max, signal) => channel.read(max, signal),
-      write: async () => {
-        throw new KernelError("EINVAL");
+      ...access2 === "write" ? {} : { read: (max, signal) => channel.read(max, signal) },
+      ...access2 === "read" ? {} : {
+        write: async () => {
+          throw new KernelError("EINVAL");
+        }
       },
       poll: () => channel.poll(),
       changed: (signal) => channel.changed(signal),
@@ -16908,7 +17075,10 @@ var SECURE_PATH = "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
 var DEFAULT_SUDOERS = "%sudo Cmnd *\n";
 var SUDO_TIMEOUT_MS = 3e5;
 var NAME3 = /^[a-z_][a-z0-9_.-]*$/;
-var RULE = /^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()\s]+)\)\s+)?Cmnd(?:\s+(.*))?$/;
+var WORD = String.raw`(?:'[^']*'|"(?:[^"\\]|\\[\s\S])*"|\\[\s\S]|[^\s'"\\])+`;
+var RULE = new RegExp(
+  String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()\s]+)\)\s+)?(?:Cwd\s+(${WORD})\s+)?Cmnd(?:\s+(.*))?$`
+);
 var TERM = /^[A-Za-z0-9._+-]+$/;
 var PLAIN = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
@@ -16943,17 +17113,25 @@ function validWho(who) {
   if (who === "ALL") return true;
   return NAME3.test(who.startsWith("%") ? who.slice(1) : who);
 }
+function cwdOf(word) {
+  const words2 = splitWords(word);
+  const path = words2?.length === 1 ? words2[0] : "";
+  return path.startsWith("/") ? normalizePath(path) : "";
+}
 function parseRule(line) {
   const text = line.trim();
   if (text === "" || text.startsWith("#")) return null;
   const m = RULE.exec(text);
   if (!m) return void 0;
-  const [, nopasswd, who = "", target = "root", rest2 = ""] = m;
+  const [, nopasswd, who = "", target = "root", dir, rest2 = ""] = m;
   if (!validWho(who) || target !== "ALL" && !NAME3.test(target)) return void 0;
-  if (rest2.trim() === "*") return { nopasswd: !!nopasswd, who, target, cmnd: "*" };
+  const cwd = dir === void 0 ? void 0 : cwdOf(dir);
+  if (cwd === "") return void 0;
+  const rule = { nopasswd: !!nopasswd, who, target, ...cwd !== void 0 ? { cwd } : {} };
+  if (rest2.trim() === "*") return { ...rule, cmnd: "*" };
   const cmnd = splitWords(rest2);
   if (!cmnd?.[0]?.startsWith("/")) return void 0;
-  return { nopasswd: !!nopasswd, who, target, cmnd };
+  return { ...rule, cmnd };
 }
 function flags(parsed2, arg, next2) {
   for (let j = 1; j < arg.length; j++) {
@@ -16992,7 +17170,8 @@ function parseArgs(args) {
 }
 function described(rule) {
   const cmnd = rule.cmnd === "*" ? "ALL" : rule.cmnd.map(quoteWord).join(" ");
-  return `    (${rule.target}) ${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}`;
+  const cwd = rule.cwd === void 0 ? "" : `CWD=${quoteWord(rule.cwd)} `;
+  return `    (${rule.target}) ${cwd}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}`;
 }
 var Sudo = class {
   o;
@@ -17132,7 +17311,7 @@ var Sudo = class {
     if (untrusted) return untrusted;
     const argv = [path, ...args];
     const matching = rules.filter(
-      (rule) => applies(rule) && (rule.target === "ALL" || rule.target === target.name) && (rule.cmnd === "*" || rule.cmnd.length === argv.length && rule.cmnd.every((w, i) => w === argv[i]))
+      (rule) => applies(rule) && (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === cwd) && (rule.cmnd === "*" || rule.cmnd.length === argv.length && rule.cmnd.every((w, i) => w === argv[i]))
     );
     const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term);
     if (root || matching.some((rule) => rule.nopasswd)) return grant();
@@ -17154,7 +17333,7 @@ var Sudo = class {
       }
       const changed = await this.untrusted(path, cwd, word);
       if (changed) return changed;
-      if (answer === "always" && !await this.remember(self, target, argv)) {
+      if (answer === "always" && !await this.remember(self, target, cwd, argv)) {
         return failed2("EIO", "sudo: the rule could not be recorded");
       }
       return grant();
@@ -17219,7 +17398,7 @@ ${lines2}
       requester.removeEventListener("abort", withdraw);
     }
   }
-  async remember(self, target, argv) {
+  async remember(self, target, cwd, argv) {
     const { fs } = this.o;
     const path = `${SUDOERS_D}/${self.name}`;
     if (!NAME3.test(self.name)) return false;
@@ -17229,7 +17408,8 @@ ${lines2}
       const st = await fs.lstat(path).catch(() => void 0);
       if (st && !await this.trusted(path)) return false;
       const old = st ? await fs.readFile(path) : "";
-      const line = `NOPASSWD ${self.name} (${target.name}) Cmnd ${argv.map(quoteWord).join(" ")}
+      const words2 = argv.map(quoteWord).join(" ");
+      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Cmnd ${words2}
 `;
       const text = old === "" || old.endsWith("\n") ? `${old}${line}` : `${old}
 ${line}`;
@@ -17362,15 +17542,25 @@ function shebang(head) {
   if (head[0] !== 35 || head[1] !== 33) return void 0;
   return new TextDecoder().decode(head.subarray(0, SHEBANG_MAX)).slice(2).split("\n")[0].trim().split(/[ \t]+/);
 }
-async function rootOnly(fs, path) {
+async function rootOnly(fs, path, dir = false) {
   const names = chain(path);
   for (const [i, at] of names.entries()) {
     const st = await fs.lstat(at).catch(() => void 0);
-    const kind = i === names.length - 1 ? st?.isFile : st?.isDirectory;
+    const kind = i === names.length - 1 && !dir ? st?.isFile : st?.isDirectory;
     if (!kind || st?.uid !== 0 || (st.mode & 18) !== 0) return false;
   }
   return true;
 }
+function appendedRoots(given) {
+  const roots = given?.append ?? [];
+  if (!Array.isArray(roots)) throw new TypeError("commands.append must be an array of paths");
+  for (const root of roots) {
+    if (typeof root !== "string" || !root.startsWith("/") || normalizePath(root) !== root) {
+      throw new TypeError(`commands.append: not an absolute, normalised path: ${String(root)}`);
+    }
+  }
+  return [...roots];
+}
 function plainEnv(words2) {
   const next2 = words2[1];
   if (baseName(words2[0] ?? "") !== "env" || next2 === void 0) return false;
@@ -17463,6 +17653,8 @@ var Launcher = class {
   base;
   createWorker;
   modulesDir;
+  appended;
+  reportedRoots = /* @__PURE__ */ new Set();
   env;
   catalogs = /* @__PURE__ */ new Map();
   ownCatalogs = /* @__PURE__ */ new Map();
@@ -17569,6 +17761,7 @@ var Launcher = class {
     this.processMounts = options.processMounts ?? true;
     this.pnpmHome = options.env?.PNPM_HOME ?? SYSTEM_PNPM_HOME;
     this.modulesDir = options.modules ?? "/node_modules";
+    this.appended = appendedRoots(options.commands);
     this.cdp = new CdpHosts(options.cdp);
     const hostname = options.hostname ?? DEFAULT_HOSTNAME;
     if (!isHostname(hostname)) throw new Error(`not a host name: ${String(hostname)}`);
@@ -17618,9 +17811,9 @@ var Launcher = class {
     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);
     const integrity = options.protect?.integrity;
     integrityOptions(integrity);
+    options.fs.protect?.(this.prefixes, Boolean(integrity));
     if (integrity && this.prefixes.length > 0) {
       this.integrity = new Integrity(
         this.prefixes,
@@ -17643,7 +17836,7 @@ var Launcher = class {
     });
     void this.unlinked.sweep("/");
     this.watchers.watch(
-      [this.modulesDir, this.pnpmHome],
+      [this.modulesDir, this.pnpmHome, ...this.appended],
       { recursive: true },
       () => this.resetCatalogs()
     );
@@ -17674,7 +17867,10 @@ var Launcher = class {
   commands(scope = "") {
     let found = this.catalogs.get(scope);
     if (!found) {
-      found = this.roots(scope).then((roots) => scanCommands(this.scanned, roots)).then((commands) => commands.set(SUDO_COMMAND.name, SUDO_COMMAND));
+      found = this.trustedAppended().then(async (appended) => {
+        const roots = await this.roots(scope, appended);
+        return scanCommands(this.scanned, roots, roots.length - appended.length);
+      }).then((commands) => commands.set(SUDO_COMMAND.name, SUDO_COMMAND));
       this.catalogs.set(scope, found);
     }
     return found;
@@ -17701,10 +17897,37 @@ var Launcher = class {
     }
     return found;
   }
-  async roots(scope = "") {
-    const system = [this.modulesDir, ...await pnpmGlobalRoots(this.base, this.pnpmHome)];
+  async roots(scope = "", appended) {
+    const system = [
+      this.modulesDir,
+      ...await pnpmGlobalRoots(this.base, this.pnpmHome),
+      ...appended ?? await this.trustedAppended()
+    ];
     return scope ? [...await pnpmGlobalRoots(this.base, scope), ...system] : system;
   }
+  async rootOnlyPath(root) {
+    for (const at of chain(root)) {
+      const real = await physicalPathAsync(this.base, at);
+      if (!await rootOnly(this.base, real, true)) return false;
+    }
+    return true;
+  }
+  async trustedAppended() {
+    if (this.appended.length === 0 || this.usersMode === "off") return this.appended;
+    const trusted = [];
+    for (const root of this.appended) {
+      const real = await physicalPathAsync(this.base, root);
+      if (await this.rootOnlyPath(root)) trusted.push(root);
+      else if (this.usersMode === "report" && await this.base.exists(real)) {
+        if (!this.reportedRoots.has(root)) {
+          this.reportedRoots.add(root);
+          this.dac?.denied({ pid: 0, uid: 0, op: "commands", path: root, errno: "EACCES" });
+        }
+        trusted.push(root);
+      }
+    }
+    return trusted;
+  }
   resetCatalogs() {
     this.catalogs.clear();
     this.ownCatalogs.clear();
@@ -17810,14 +18033,22 @@ var Launcher = class {
       const inner = await this.interpreted(interp, [interp, ...passed], cwd, scope, depth + 1);
       const via = [interp, ...inner?.via ?? []];
       const sources = [script, ...inner?.sources ?? []];
-      return inner && { ...inner, target: withScriptEnv(inner.target, command), via, sources };
+      const bins = [...command?.bin ? [script] : [], ...inner?.bins ?? []];
+      return inner && {
+        ...inner,
+        target: withScriptEnv(inner.target, command),
+        via,
+        sources,
+        ...bins.length > 0 ? { bins } : {}
+      };
     }
     const target = withScriptEnv(found, command);
     return {
       target,
       args: [...target.prefix ?? [], ...passed],
       via: [interp],
-      sources: [script]
+      sources: [script],
+      ...command?.bin ? { bins: [script] } : {}
     };
   }
   async plan(file, argv, cwd, scope, argv0) {
@@ -17843,6 +18074,7 @@ var Launcher = class {
       const want = i < via.length - 1 ? R_OK | X_OK : X_OK;
       await need(g, "exec", this.fs.resolvePath(req.cwd, file), want);
     }
+    for (const bin of planned?.bins ?? []) await need(g, "exec", bin, R_OK | X_OK);
   }
   async checkedPlan(req, { ppid, cred, scope }, fds) {
     const planned = await this.plan(req.file, req.argv, req.cwd, scope, req.argv0);
@@ -18141,6 +18373,7 @@ var Launcher = class {
       },
       settling: () => this.settling.isSettling(pid),
       ...req.ignored ? { ignored: req.ignored } : {},
+      ...req.blocked ? { blocked: req.blocked } : {},
       ...req.umask !== void 0 ? { umask: req.umask } : {},
       cred: req.cred,
       ...this.owners && req.program.abi === "wasi" ? { fresh: (path, umask) => this.freshModules.add(path, umask, pid) } : {},
@@ -18415,6 +18648,7 @@ var Launcher = class {
         report,
         ppid,
         ignored: this.ignoredBy(ppid),
+        blocked: this.blockedBy(ppid),
         umask: this.umaskOf(ppid),
         cred,
         tag: this.tagOf(ppid),
@@ -18476,6 +18710,7 @@ var Launcher = class {
         ppid,
         fork: state,
         ignored: this.ignoredBy(ppid, true),
+        blocked: this.blockedBy(ppid),
         umask: this.umaskOf(ppid),
         cred: this.credOf(ppid),
         tag: this.tagOf(ppid)
@@ -18527,11 +18762,16 @@ var Launcher = class {
   }
   signalMasksOf(pid) {
     const masks = this.processes.get(pid)?.signalMasks?.();
-    return masks ? { sigIgn: masks.ignored, sigCgt: masks.caught } : {};
+    const blocked = this.blockedBy(pid);
+    const sigBlk = blocked ? { sigBlk: blocked } : {};
+    return masks ? { sigIgn: masks.ignored, sigCgt: masks.caught, ...sigBlk } : sigBlk;
   }
   controlsJobs(pid) {
     return this.settling.isSettling(pid) || (this.ignoredBy(pid) & sigbit(SIG.TTOU)) !== 0;
   }
+  blockedBy(pid) {
+    return this.processes.get(pid)?.blockedSignals?.() ?? 0;
+  }
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
@@ -18896,7 +19136,7 @@ var Launcher = class {
       (dir) => this.userCommandDir(dir),
       this.owners
     );
-    const nodes = new VfsNodes(fs, (path) => this.released(path));
+    const nodes = new VfsNodes(fs, (path) => this.released(path), this.nodes.entries);
     nodes.keepsOnDisk = true;
     this.openFiles.add(nodes);
     const unlinked = new UnlinkedKeeper(
@@ -19300,6 +19540,7 @@ function serveKernel(port, deps) {
         createWorker: deps.createWorker,
         ...deps.createDriverWorker ? { createDriverWorker: deps.createDriverWorker } : {},
         ...req.modules ? { modules: req.modules } : {},
+        ...req.commands ? { commands: req.commands } : {},
         ...req.env ? { env: req.env } : {},
         ...hostOptions(req, port, sealed.hook, clipboard.hook, integrity.lookup),
         ...req.approve ? { approve: approvals.ask } : {},