@ai-ecoverse/slicc-kernel 1.87.0 → 1.88.1

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) {
@@ -4559,12 +4580,12 @@ async function interruptible(work, signal) {
   if (signal.aborted) throw new KernelError("EINTR");
   let stop = () => {
   };
-  const interrupted2 = new Promise((_, reject) => {
+  const interrupted3 = new Promise((_, reject) => {
     stop = () => reject(new KernelError("EINTR"));
     signal.addEventListener("abort", stop, { once: true });
   });
   try {
-    return await Promise.race([work, interrupted2]);
+    return await Promise.race([work, interrupted3]);
   } finally {
     signal.removeEventListener("abort", stop);
   }
@@ -7131,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(/^\.\//, "");
@@ -7222,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);
@@ -7274,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")) {
@@ -7744,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 };
 }
@@ -7769,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;
@@ -9501,11 +9594,12 @@ var MountFs = class {
     });
   }
   async chmod(path, mode) {
-    const found = this.at(path);
-    if (!found) return this.base.chmod(path, mode);
-    this.writable(found.mount, normalizePath(path));
+    const real = await this.follow(path);
+    const found = this.at(real);
+    if (!found) return this.base.chmod(real, mode);
+    this.writable(found.mount, real);
     if (!found.mount.caps.chmod) return;
-    this.table.forget(found.mount, normalizePath(path));
+    this.table.forget(found.mount, real);
     await found.mount.conn.call({ op: "setattr", path: found.rel, mode });
   }
   async utimes(path, atime, mtime) {
@@ -9975,7 +10069,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;
@@ -9995,6 +10089,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));
@@ -10520,12 +10615,32 @@ function mountTable(mounts = []) {
 `;
 }
 
+// src/version.ts
+var KERNEL_VERSION = true ? "1.88.1" : "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);
@@ -10613,7 +10728,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)}`,
     ""
@@ -10649,6 +10764,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)}
 `;
@@ -10739,11 +10855,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;
     }
@@ -10821,7 +10943,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 !== "");
@@ -10840,7 +10962,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);
@@ -12061,16 +12183,16 @@ function interruption(signal) {
 }
 async function selectFds(fds, read, write, timeoutMs, interrupt) {
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-  const interrupted2 = interruption(interrupt);
-  interrupted2.promise.catch(() => {
+  const interrupted3 = interruption(interrupt);
+  interrupted3.promise.catch(() => {
   });
   try {
-    return await waitReady(fds, read, write, deadline, interrupted2.promise);
+    return await waitReady(fds, read, write, deadline, interrupted3.promise);
   } finally {
-    interrupted2.done();
+    interrupted3.done();
   }
 }
-async function waitReady(fds, read, write, deadline, interrupted2) {
+async function waitReady(fds, read, write, deadline, interrupted3) {
   for (; ; ) {
     const now = ready(fds, read, write);
     if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
@@ -12082,7 +12204,7 @@ async function waitReady(fds, read, write, deadline, interrupted2) {
     let timer;
     const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => timer = setTimeout(resolve2, deadline - Date.now()))];
     try {
-      await Promise.race([...changes, ...expiry, interrupted2]);
+      await Promise.race([...changes, ...expiry, interrupted3]);
     } finally {
       round.abort();
       clearTimeout(timer);
@@ -12399,11 +12521,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);
@@ -12893,6 +13016,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;
@@ -12927,7 +13051,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;
@@ -12955,6 +13082,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;
@@ -12971,16 +13102,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");
@@ -13879,6 +14021,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();
@@ -13958,19 +14102,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 {
@@ -14095,15 +14245,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,
@@ -14116,12 +14267,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(
@@ -14222,6 +14376,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)
@@ -14243,7 +14398,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),
@@ -14265,6 +14420,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),
@@ -14977,63 +15133,137 @@ function compile(secrets, options = {}) {
 
 // src/kernel/scrub-file.ts
 var SCRUB_IDLE_MS = 50;
+var SCRUB_NONBLOCK_MAX = 64 * 1024;
 var encoder5 = new TextEncoder();
 function scrubberOf(secrets) {
   const usable = secrets.filter((s) => encoder5.encode(s.value).length >= MIN_VALUE);
   return usable.length > 0 ? compile(usable, { idleMs: SCRUB_IDLE_MS }) : void 0;
 }
-async function writeAll2(file, bytes, signal) {
+async function writeAll2(file, bytes) {
   const write = file.write;
-  for (let at = 0; at < bytes.length; ) {
-    at += await write.call(file, bytes.subarray(at), at === 0 ? signal : void 0);
-  }
+  for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
 function bound(file, key) {
   const method = file[key];
   return typeof method === "function" ? { [key]: method.bind(file) } : {};
 }
+function interrupted2(err) {
+  const code = err?.code;
+  return code === "EINTR" || code === "EAGAIN";
+}
 function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   const file = inner.file;
   const stream = scrubber.stream();
-  let queue = Promise.resolve();
+  let tail = Promise.resolve();
+  let pending = 0;
+  let busy = false;
   let timer;
   let failed3;
+  const waiters = /* @__PURE__ */ new Set();
+  const quiet = () => !busy && pending === 0;
+  const wake = () => {
+    for (const waiter of [...waiters]) waiter();
+  };
   const raise = () => {
     if (failed3 === void 0) return;
     const err = failed3;
     failed3 = void 0;
     throw err;
   };
-  const enqueue = (bytes, signal) => {
-    const next2 = queue.then(() => bytes.length > 0 ? writeAll2(file, bytes, signal) : void 0);
-    queue = next2.catch(() => void 0);
-    return next2;
+  const later = (bytes) => {
+    if (bytes.length === 0) return;
+    pending += 1;
+    tail = tail.then(() => writeAll2(file, bytes)).catch((err) => {
+      if (failed3 === void 0) failed3 = err;
+    }).finally(() => {
+      pending -= 1;
+      if (quiet()) wake();
+    });
+  };
+  const settling = (signal) => new Promise((resolve2, reject) => {
+    const done4 = () => {
+      waiters.delete(done4);
+      signal?.removeEventListener("abort", stop);
+      resolve2();
+    };
+    const stop = () => {
+      waiters.delete(done4);
+      reject(new KernelError("EINTR"));
+    };
+    if (signal?.aborted) return stop();
+    waiters.add(done4);
+    signal?.addEventListener("abort", stop, { once: true });
+  });
+  const settled = async () => {
+    while (!quiet()) await settling();
+  };
+  const changed = async (signal) => {
+    const round = new AbortController();
+    const stop = signal ? AbortSignal.any([signal, round.signal]) : round.signal;
+    try {
+      const own = settling(stop);
+      await Promise.race(file.changed ? [own, file.changed(stop)] : [own]);
+    } catch (err) {
+      throw signal?.aborted ? new KernelError("EINTR") : err;
+    } finally {
+      round.abort();
+    }
+  };
+  const turn = async (signal) => {
+    for (let waited = false; ; waited = true) {
+      if (quiet() && (pollFile(file).writable || !file.changed)) {
+        busy = true;
+        return;
+      }
+      if (signal?.aborted) throw new KernelError(waited ? "EINTR" : "EAGAIN");
+      await changed(signal);
+    }
+  };
+  const send = async (out, signal) => {
+    const write = file.write;
+    for (let at = 0; at < out.length; ) {
+      try {
+        at += await write.call(file, out.subarray(at), signal);
+      } catch (err) {
+        if (!signal?.aborted || !interrupted2(err)) throw err;
+      }
+      if (at < out.length && signal?.aborted) return later(out.subarray(at));
+    }
   };
   const release = () => {
     timer = void 0;
-    enqueue(stream.idle()).catch((err) => {
-      failed3 = err;
-    });
+    later(stream.idle());
   };
   return new OpenFile({
     ...bound(file, "read"),
     ...bound(file, "peek"),
-    ...bound(file, "poll"),
-    ...bound(file, "changed"),
     ...bound(file, "stat"),
+    poll: () => {
+      const state = pollFile(file);
+      return quiet() ? state : { ...state, writable: false };
+    },
+    changed,
     ...file.tty ? { tty: file.tty } : {},
     ...file.clipboard ? { clipboard: file.clipboard } : {},
     ...file.write ? {
       write: async (bytes, signal) => {
-        if (timer !== void 0) clearTimeout(timer);
-        raise();
-        await enqueue(stream.push(bytes), signal);
+        await turn(signal);
+        const taken = signal?.aborted && bytes.length > SCRUB_NONBLOCK_MAX ? bytes.subarray(0, SCRUB_NONBLOCK_MAX) : bytes;
+        try {
+          raise();
+          if (timer !== void 0) clearTimeout(timer);
+          timer = void 0;
+          await send(stream.push(taken), signal);
+        } finally {
+          busy = false;
+          if (quiet()) wake();
+        }
         timer = setTimeout(release, idleMs);
-        return bytes.length;
+        return taken.length;
       }
     } : {},
     flush: async () => {
-      await queue;
+      await settled();
       raise();
       await file.flush?.();
     },
@@ -15041,7 +15271,9 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
       if (timer !== void 0) clearTimeout(timer);
       let failure2;
       try {
-        await enqueue(stream.end());
+        await settled();
+        later(stream.end());
+        await settled();
         raise();
       } catch (err) {
         failure2 = { err };
@@ -15217,12 +15449,12 @@ var SealedChannel = class {
     if (signal.aborted) throw new KernelError("EINTR");
     let stop = () => {
     };
-    const interrupted2 = new Promise((_, reject) => {
+    const interrupted3 = new Promise((_, reject) => {
       stop = () => reject(new KernelError("EINTR"));
       signal.addEventListener("abort", stop, { once: true });
     });
     try {
-      await Promise.race([flight.done, interrupted2]);
+      await Promise.race([flight.done, interrupted3]);
     } finally {
       signal.removeEventListener("abort", stop);
     }
@@ -17387,15 +17619,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;
@@ -17488,6 +17730,8 @@ var Launcher = class {
   base;
   createWorker;
   modulesDir;
+  appended;
+  reportedRoots = /* @__PURE__ */ new Set();
   env;
   catalogs = /* @__PURE__ */ new Map();
   ownCatalogs = /* @__PURE__ */ new Map();
@@ -17594,6 +17838,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)}`);
@@ -17643,9 +17888,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,
@@ -17668,7 +17913,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()
     );
@@ -17699,7 +17944,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;
@@ -17726,10 +17974,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();
@@ -17835,14 +18110,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) {
@@ -17868,6 +18151,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);
@@ -18133,11 +18417,9 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
-  treeScrubs(pid, req) {
+  treeScrubs(req) {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
-    const scrubs = req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
-    if (scrubs) this.scrubs.set(pid, scrubs);
-    return scrubs;
+    return req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
   }
   start(req) {
     this.sampling();
@@ -18145,7 +18427,7 @@ var Launcher = class {
       throw new SpawnError("ESRCH");
     }
     const pid = req.pid ?? this.nextPid++;
-    const scrubs = this.treeScrubs(pid, req);
+    const scrubs = this.treeScrubs(req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
     const decided = req.decided ?? Promise.resolve(true);
@@ -18166,6 +18448,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) } : {},
@@ -18214,6 +18497,7 @@ var Launcher = class {
       ...this.shownIds(req)
     });
     this.processes.set(pid, handle);
+    if (scrubs) this.scrubs.set(pid, scrubs);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
     if (req.tag !== void 0) this.tags.set(pid, req.tag);
@@ -18440,6 +18724,7 @@ var Launcher = class {
         report,
         ppid,
         ignored: this.ignoredBy(ppid),
+        blocked: this.blockedBy(ppid),
         umask: this.umaskOf(ppid),
         cred,
         tag: this.tagOf(ppid),
@@ -18501,6 +18786,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)
@@ -18552,11 +18838,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;
   }
@@ -18921,7 +19212,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(
@@ -19325,6 +19616,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 } : {},