@ai-ecoverse/slicc-kernel 1.129.0 → 1.130.1

package/dist/kernel-worker.js

@@ -636,8 +636,8 @@ var Integrity = class {
     }
   }
   async expected(path) {
-    const answer = await this.lookup(path);
-    return typeof answer === "string" ? answer.toLowerCase() : void 0;
+    const answer2 = await this.lookup(path);
+    return typeof answer2 === "string" ? answer2.toLowerCase() : void 0;
   }
   say(event) {
     try {
@@ -890,10 +890,12 @@ var RemoteWatch = class {
   quiet;
   crowd;
   told;
+  counted = 0;
   recount() {
     const now = this.crowded();
-    if (now === this.told) return;
+    if (now === this.told && this.peers.size === this.counted) return;
     this.told = now;
+    this.counted = this.peers.size;
     this.crowd?.(now);
   }
   constructor(name2, options = {}) {
@@ -983,12 +985,12 @@ var RemoteWatch = class {
   }
   greeted(peer) {
     this.arrived(peer);
-    const answer = () => {
+    const answer2 = () => {
       this.channel.postMessage({ here: this.tab, to: peer });
       if (this.mine.length > 0) void this.announce(this.mine);
     };
-    if (this.quiet) void this.quiet().then(answer, answer);
-    else answer();
+    if (this.quiet) void this.quiet().then(answer2, answer2);
+    else answer2();
   }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
@@ -7020,7 +7022,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.129.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.130.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
@@ -9414,6 +9416,9 @@ var FileChanges = class {
   foreign(on) {
     Atomics.store(this.view, FOREIGN, on ? 1 : 0);
   }
+  flush() {
+    Atomics.add(this.view, GEN, RING_SIZE + 1);
+  }
   publish(...paths) {
     for (const path of paths) {
       const g = Atomics.add(this.view, GEN, 1) + 1 | 0;
@@ -16336,11 +16341,11 @@ function carriesUdp(uplink) {
   return uplink.traits.udp === true && typeof uplink.udp === "function";
 }
 function answerOf(result) {
-  const answer = Array.isArray(result) ? { addresses: result } : result;
-  const addresses = Array.isArray(answer?.addresses) ? answer.addresses.filter((a) => typeof a === "string") : [];
+  const answer2 = Array.isArray(result) ? { addresses: result } : result;
+  const addresses = Array.isArray(answer2?.addresses) ? answer2.addresses.filter((a) => typeof a === "string") : [];
   return {
     addresses,
-    ...typeof answer?.ttl === "number" && answer.ttl >= 0 ? { ttl: answer.ttl } : {}
+    ...typeof answer2?.ttl === "number" && answer2.ttl >= 0 ? { ttl: answer2.ttl } : {}
   };
 }
 var NEVER = new Routes(true);
@@ -16528,9 +16533,9 @@ var Resolver = class {
   async lookup(name2, family, id2, abandoned) {
     const uplink = this.uplink;
     const timeout = AbortSignal.any([AbortSignal.timeout(this.timeoutMs), abandoned]);
-    let answer;
+    let answer2;
     try {
-      answer = answerOf(
+      answer2 = answerOf(
         await Promise.race([
           uplink.resolve(name2, family, timeout),
           new Promise(
@@ -16541,8 +16546,8 @@ var Resolver = class {
     } catch {
       return [];
     }
-    const addresses = answer.addresses.filter((a) => this.usable(name2, a, family));
-    if (addresses.length > 0) this.remember(id2, addresses, answer.ttl);
+    const addresses = answer2.addresses.filter((a) => this.usable(name2, a, family));
+    if (addresses.length > 0) this.remember(id2, addresses, answer2.ttl);
     return addresses;
   }
   usable(name2, address, family) {
@@ -21198,8 +21203,8 @@ var WasmProcess = class {
   spares(sig) {
     const { caught, ignored } = this.signalMasks();
     const bit = isSignal(sig) ? sigbit(sig) : 0;
-    const answer = (ignored & bit) !== 0 ? "ignore" : (caught & bit) !== 0 ? "spare" : "terminate";
-    return { ok: true, kind: "json", json: answer };
+    const answer2 = (ignored & bit) !== 0 ? "ignore" : (caught & bit) !== 0 ? "spare" : "terminate";
+    return { ok: true, kind: "json", json: answer2 };
   }
   async killSelf(sig, target, probe) {
     if (!this.options.exitSignal) throw new KernelError("ENOSYS");
@@ -22316,10 +22321,10 @@ var WasmProcess = class {
       cwd: typeof req.cwd === "string" && req.cwd.startsWith("/") ? req.cwd : "/",
       ...typeof req.term === "string" ? { term: req.term } : {}
     };
-    const answer = await sudo(call, this.blockingSignal(cancelled));
-    if (!("grant" in answer)) return answer;
+    const answer2 = await sudo(call, this.blockingSignal(cancelled));
+    if (!("grant" in answer2)) return answer2;
     if (this.dying) throw new KernelError("EINTR");
-    const { file, argv, env, cwd, cred, caller } = answer.grant;
+    const { file, argv, env, cwd, cred, caller } = answer2.grant;
     const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
     return {
       pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
@@ -22479,6 +22484,153 @@ var WASM_THREAD_SPAWN = "wasm-thread-spawn";
 var WASM_THREAD_INIT = "wasm-thread-init";
 var WASM_THREAD_EXIT = "wasm-thread-exit";
 var WASM_MAX_THREADS = 256;
+var JS_THREAD_SPAWN = "js-thread-spawn";
+var JS_THREAD_INIT = "js-thread-init";
+var JS_THREAD_EXIT = "js-thread-exit";
+var JS_MAX_THREADS = 256;
+var JS_DEFAULT_THREADS = 16;
+var JS_THREAD_NO_MEMORY = 256;
+var JS_THREAD_CRASHED = 257;
+
+// src/kernel/js-threads.ts
+var JS_OOM = /out of memory|Array buffer allocation failed|Cannot allocate Wasm memory|could not allocate memory|ERR_WORKER_OUT_OF_MEMORY/i;
+var ENDING = { ok: false, errno: "EINTR", message: "the thread is ending" };
+var MAIN_ONLY = { ok: true, kind: "void" };
+function track(ops, req, result) {
+  if (req.op === "async-submit" && result.ok && result.kind === "json") {
+    if (typeof result.json === "number") ops.set(result.json, req.token);
+  } else if (req.op === "async-cancel" || req.op === "async-take" && (result.ok || result.errno !== "EAGAIN")) {
+    ops.delete(req.id);
+  }
+}
+function cores() {
+  const n = globalThis.navigator?.hardwareConcurrency;
+  return typeof n === "number" && Number.isInteger(n) && n > 0 ? n : 0;
+}
+function jsThreadCap(env) {
+  const asked = Number.parseInt(env.SLICC_JS_THREADS ?? "", 10);
+  if (asked >= 1) return Math.min(asked, JS_MAX_THREADS);
+  return Math.min(JS_MAX_THREADS, Math.max(JS_DEFAULT_THREADS, 2 * cores()));
+}
+function codeOf4(code) {
+  if (code === JS_THREAD_NO_MEMORY || code === JS_THREAD_CRASHED) return code;
+  return typeof code === "number" && Number.isInteger(code) ? code & 255 : JS_THREAD_CRASHED;
+}
+function answer(control, message3) {
+  control.postMessage(message3);
+}
+var JsThreads = class {
+  deps;
+  live = /* @__PURE__ */ new Map();
+  headers = /* @__PURE__ */ new Map();
+  frozen = false;
+  last = 0;
+  closed = false;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  get size() {
+    return this.live.size;
+  }
+  spawn(msg) {
+    const { control, port } = msg;
+    if (this.closed || this.live.size >= this.deps.cap) {
+      answer(
+        control,
+        this.closed ? { errno: "ESRCH", message: "the process is ending" } : { errno: "EAGAIN", message: `more than ${this.deps.cap} threads` }
+      );
+      control.close();
+      port.close();
+      return;
+    }
+    const tid = ++this.last;
+    const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
+    const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
+    if (this.frozen) Atomics.store(header3, SAB_I_STOP, 1);
+    const worker = this.deps.createWorker();
+    const clock = this.deps.clocks.thread(tid + 1, sab);
+    let ended = false;
+    const end = (code) => {
+      if (ended) return;
+      ended = true;
+      this.live.delete(tid);
+      this.headers.delete(tid);
+      this.deps.wakes.delete(header3);
+      for (const [id2, token] of ops) {
+        void this.deps.dispatch({ op: "async-cancel", id: id2, token });
+      }
+      ops.clear();
+      worker.removeEventListener("message", onMessage);
+      worker.removeEventListener("error", onError);
+      control.removeEventListener("message", onControl);
+      responder.dispose();
+      lane.dispose();
+      this.deps.clocks.threadEnded(tid + 1);
+      worker.terminate();
+      answer(control, { exited: code });
+      control.close();
+    };
+    const ops = /* @__PURE__ */ new Map();
+    const dispatch2 = async (req, block) => {
+      if (isWasmSyscall(req) && req.op === "proc-exit") {
+        queueMicrotask(() => end(req.status & 255));
+        return ENDING;
+      }
+      if (isWasmSyscall(req) && req.op === "sig-mask") return MAIN_ONLY;
+      const result = await this.deps.dispatch(req, block);
+      if (!ended) track(ops, req, result);
+      return result;
+    };
+    const responder = this.deps.attach(worker, sab, this.deps.clocks.timed(clock, dispatch2));
+    const lane = this.deps.openLane(dispatch2);
+    const onMessage = (event) => {
+      const data = event.data;
+      if (data?.type === JS_THREAD_EXIT) end(codeOf4(data.code));
+      else if (data?.type === JS_THREAD_SPAWN) this.spawn(event.data);
+      else if (data?.type === WASM_PROCESS_ERROR) this.crashed(String(data.message), end);
+    };
+    const onError = (event) => {
+      event.preventDefault();
+      this.crashed(String(event.message ?? "worker error"), end);
+    };
+    const onControl = (event) => {
+      if (event.data?.terminate === true) end(1);
+    };
+    worker.addEventListener("message", onMessage);
+    worker.addEventListener("error", onError);
+    control.addEventListener("message", onControl);
+    control.start();
+    this.live.set(tid, end);
+    this.headers.set(tid, header3);
+    this.deps.wakes.add(header3);
+    const init = {
+      ...this.deps.init(sab, lane.lane),
+      type: JS_THREAD_INIT,
+      thread: { tid, port, data: msg.data }
+    };
+    try {
+      worker.postMessage(init, [lane.lane.port, port, ...msg.transfer ?? []]);
+    } catch {
+      end(JS_THREAD_CRASHED);
+      return;
+    }
+    answer(control, { tid });
+  }
+  crashed(message3, end) {
+    end(JS_OOM.test(message3) ? JS_THREAD_NO_MEMORY : JS_THREAD_CRASHED);
+  }
+  stopped(stopped) {
+    this.frozen = stopped;
+    for (const header3 of this.headers.values()) {
+      Atomics.store(header3, SAB_I_STOP, stopped ? 1 : 0);
+      Atomics.notify(header3, SAB_I_STOP);
+    }
+  }
+  close() {
+    this.closed = true;
+    for (const end of [...this.live.values()]) end(1);
+  }
+};
 
 // src/kernel/host.ts
 var CRASHED = 70;
@@ -22581,6 +22733,7 @@ function threadSignalsOf(sab) {
 function threadCancel(thread) {
   return unblocked(thread.header) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
 }
+var asyncFanout = /* @__PURE__ */ new WeakMap();
 function notifiers(header3) {
   return {
     onPending(sig) {
@@ -22588,8 +22741,10 @@ function notifiers(header3) {
       Atomics.notify(header3, SAB_I_SIGNALS);
     },
     onAsync() {
-      Atomics.add(header3, SAB_I_ASYNC, 1);
-      Atomics.notify(header3, SAB_I_ASYNC);
+      for (const at of [header3, ...asyncFanout.get(header3) ?? []]) {
+        Atomics.add(at, SAB_I_ASYNC, 1);
+        Atomics.notify(at, SAB_I_ASYNC);
+      }
     }
   };
 }
@@ -22820,6 +22975,7 @@ function spawnWasmProcess(opts) {
     dispatch: clocks.timed(void 0, dispatch2)
   });
   const lane = opts.program.abi === "js" ? openLane(token, dispatch2) : void 0;
+  const jsThreads = jsThreadsOf(opts, process, token, dispatch2, clocks, header3);
   const { promise: exited, resolve: settle3 } = Promise.withResolvers();
   let done5 = false;
   let endedBy;
@@ -22833,6 +22989,7 @@ function spawnWasmProcess(opts) {
     worker.removeEventListener("message", onMessage);
     worker.removeEventListener("error", onError);
     for (const tid of [...threads.keys()]) endThread(tid);
+    jsThreads?.close();
     responder.dispose();
     lane?.dispose();
     revokeSyncFsToken(token);
@@ -22856,6 +23013,8 @@ function spawnWasmProcess(opts) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
+    } else if (data?.type === JS_THREAD_SPAWN && jsThreads) {
+      jsThreads.spawn(data);
     }
   };
   const onMessage = (event) => handle(event.data);
@@ -22929,13 +23088,35 @@ function spawnWasmProcess(opts) {
     termsig: () => endedBy,
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header3, SAB_I_MEMORY) * 65536,
+    ...processViews(process, opts, header3),
+    writesBack: () => opts.program.abi === "wasi" && !done5,
+    ...clockViews(clocks)
+  };
+}
+function jsThreadsOf(opts, process, token, dispatch2, clocks, header3) {
+  if (opts.program.abi !== "js") return void 0;
+  const wakes = /* @__PURE__ */ new Set();
+  asyncFanout.set(header3, wakes);
+  const threads = new JsThreads({
+    wakes,
+    cap: jsThreadCap(opts.env),
+    createWorker: opts.createWorker,
+    init: (sab, lane) => processInit(opts, sab, process.umask, copyCred(process.cred), lane),
+    openLane: (laneDispatch) => openLane(token, laneDispatch),
+    attach: (worker, sab, threadDispatch) => attachSyncSabResponder(worker, sab, token, { dispatch: threadDispatch }),
+    dispatch: dispatch2,
+    clocks
+  });
+  process.onState((state) => threads.stopped(state === "stopped"));
+  return threads;
+}
+function processViews(process, opts, header3) {
+  return {
     ignoredSignals: (fork) => process.inheritable(fork),
     blockedSignals: () => opts.program.abi === "wasi" ? loadBlocked(header3) : [0, 0],
     signalMasks: () => process.signalMasks(),
     umask: () => process.umask,
-    cred: () => copyCred(process.cred),
-    writesBack: () => opts.program.abi === "wasi" && !done5,
-    ...clockViews(clocks)
+    cred: () => copyCred(process.cred)
   };
 }
 function clockViews(clocks) {
@@ -24253,8 +24434,8 @@ var FSA_CAPABILITIES = {
   ranges: true,
   sessions: true
 };
-var codeOf4 = (err) => err?.code;
-var denied = (err) => codeOf4(err) === "EACCES" || err?.name === "NotAllowedError";
+var codeOf5 = (err) => err?.code;
+var denied = (err) => codeOf5(err) === "EACCES" || err?.name === "NotAllowedError";
 function attrOf(st) {
   return {
     kind: st.isDirectory ? "directory" : st.isSymbolicLink ? "symlink" : "file",
@@ -24276,7 +24457,7 @@ function kernelFsHandlers(fs) {
     try {
       return await fs.stat(path);
     } catch (err) {
-      if (codeOf4(err) === "ENOENT") return void 0;
+      if (codeOf5(err) === "ENOENT") return void 0;
       throw err;
     }
   }
@@ -24469,7 +24650,7 @@ function parseFstab(text) {
   });
   return lines2;
 }
-function codeOf5(err) {
+function codeOf6(err) {
   const code = err?.code;
   return typeof code === "string" ? code : "EIO";
 }
@@ -24507,18 +24688,18 @@ async function mountLine({ line, spec, invalid }, mount, signal, retries, discar
       break;
     } catch (err) {
       failed3 = err;
-      if (FINAL.has(codeOf5(err)) || attempt === retries.length) break;
+      if (FINAL.has(codeOf6(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf5(failed3);
+  const code = codeOf6(failed3);
   return { line, target: spec.target, code, error: String(failed3?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
-var codeOf6 = (err) => err?.code;
-var unreachable = (err) => codeOf6(err) === "ENOTCONN";
+var codeOf7 = (err) => err?.code;
+var unreachable = (err) => codeOf7(err) === "ENOTCONN";
 function rel(path) {
   return path.replace(/^\/+/, "");
 }
@@ -24695,7 +24876,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     try {
       return { opened: await opening2(), restore: void 0 };
     } catch (err) {
-      if (!flags2.write || codeOf6(err) !== "EACCES") throw err;
+      if (!flags2.write || codeOf7(err) !== "EACCES") throw err;
       const was = await client.call("stat", { path: rel(path) });
       const mode = was.mode ?? 0;
       if (mode & 128) throw err;
@@ -25915,14 +26096,14 @@ var Sudo = class {
     if (this.pending.has(cred.ruid)) return failed2("EBUSY", "sudo: another request is pending");
     this.pending.add(cred.ruid);
     try {
-      const answer = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
-      if (typeof answer !== "string") return answer;
+      const answer2 = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
+      if (typeof answer2 !== "string") return answer2;
       if (await this.canonical(call.cwd) !== cwd || !await this.reachable(cred, cwd)) {
         return failed2("EACCES", `sudo: ${call.cwd} changed while the request waited`);
       }
       const changed = await this.untrusted(path, cwd, word);
       if (changed) return changed;
-      if (answer === "always" && !await this.remember(self, target, cwd, argv)) {
+      if (answer2 === "always" && !await this.remember(self, target, cwd, argv)) {
         return failed2("EIO", "sudo: the rule could not be recorded");
       }
       return grant();
@@ -25977,11 +26158,11 @@ ${lines2}
     );
     try {
       const answered2 = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
-      const answer = await Promise.race([answered2, aborted2]);
-      if (answer === "aborted" || control.signal.aborted) {
+      const answer2 = await Promise.race([answered2, aborted2]);
+      if (answer2 === "aborted" || control.signal.aborted) {
         return control.signal.reason === "expired" ? failed2("ETIMEDOUT", "sudo: the request expired") : failed2("EINTR", "sudo: the request was withdrawn");
       }
-      return answer === "once" || answer === "always" ? answer : failed2("EACCES", "sudo: approval denied");
+      return answer2 === "once" || answer2 === "always" ? answer2 : failed2("EACCES", "sudo: approval denied");
     } finally {
       clearTimeout(timer);
       requester.removeEventListener("abort", withdraw);
@@ -26393,9 +26574,7 @@ var Launcher = class {
     this.usersMode = usersMode(options.users);
     this.memories = memoriesOf(options.wasmMemories);
     this.rootFs = options.fs;
-    const peers = options.fs.peers?.();
-    this.locks = kernelLocks(options.fs.rootName, peers);
-    peers?.watch((crowded) => this.changes.foreign(crowded));
+    this.locks = kernelLocks(options.fs.rootName, this.flushingPeers(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.clipboard = new ClipboardBroker(
@@ -26481,7 +26660,10 @@ var Launcher = class {
     this.nodes.keepsOnDisk = true;
     this.openFiles.add(this.nodes);
     options.fs.onPeer?.(() => this.flushOpen());
-    options.fs.remoteChanges?.((change) => this.rewritten(change.paths));
+    options.fs.remoteChanges?.((change) => {
+      this.changes.flush();
+      this.rewritten(change.paths);
+    });
     const holders = [this.held, this.openFiles];
     this.unlinked = new UnlinkedKeeper(
       fs,
@@ -26896,7 +27078,7 @@ var Launcher = class {
     try {
       return await this.planOne(req, ctx);
     } catch (err) {
-      const code = codeOf7(err);
+      const code = codeOf8(err);
       const searched = bare && req.search !== false && (code === "ENOENT" || code === "ENOEXEC");
       if (!searched || await this.commandAt(req.file, ctx.scope)) throw err;
       const found = await this.onPath(req, ctx);
@@ -26913,7 +27095,7 @@ var Launcher = class {
       try {
         return await this.planOne({ ...req, file }, ctx);
       } catch (err) {
-        const code = codeOf7(err);
+        const code = codeOf8(err);
         if (code === "EACCES") denied2 = true;
         else if (code !== "ENOENT" && code !== "ENOTDIR") throw err;
       }
@@ -26923,7 +27105,7 @@ var Launcher = class {
   }
   async planOne(req, { ppid, cred, scope }) {
     const refused3 = (err) => {
-      throw codeOf7(err) === "EACCES" ? new SpawnError("EACCES") : err;
+      throw codeOf8(err) === "EACCES" ? new SpawnError("EACCES") : err;
     };
     const file = await this.execFile(req.file, req.cwd, this.execGuard(cred, ppid)).catch(refused3);
     const planned = await this.plan(file, req.argv, req.cwd, scope, req.argv0);
@@ -28251,6 +28433,21 @@ var Launcher = class {
     this.writers ??= this.writerStack();
     return this.writers;
   }
+  flushingPeers(fs) {
+    const peers = fs.peers?.();
+    if (!peers) return void 0;
+    peers.watch((crowded) => {
+      this.changes.flush();
+      this.changes.foreign(crowded);
+    });
+    return {
+      ...peers,
+      fresh: () => {
+        this.changes.flush();
+        peers.fresh?.();
+      }
+    };
+  }
   rewritten(paths) {
     for (const nodes of this.openFiles) for (const path of paths) nodes.rewritten(path);
     this.changes.publish(...paths);
@@ -28433,7 +28630,7 @@ var Launcher = class {
 function cronLocks() {
   return globalThis.navigator?.locks;
 }
-function codeOf7(err) {
+function codeOf8(err) {
   return err?.code;
 }
 
@@ -28473,14 +28670,14 @@ function clipboardAsker(port) {
       await ask("write", stamp, text);
     }
   };
-  const answer = ({ id: id2, text, error }) => {
+  const answer2 = ({ id: id2, text, error }) => {
     const waiting = asks.get(id2);
     if (!waiting) return;
     asks.delete(id2);
     if (error) waiting.reject(Object.assign(new Error(error.message), { name: error.name }));
     else waiting.resolve(text);
   };
-  return { hook, answer };
+  return { hook, answer: answer2 };
 }
 
 // src/integrity-relay.ts
@@ -28494,14 +28691,14 @@ function integrityAsker(port) {
     port.postMessage({ integrityAsk: { id: id2, path } });
     return waiting.promise;
   };
-  const answer = ({ id: id2, hash, error }) => {
+  const answer2 = ({ id: id2, hash, error }) => {
     const waiting = asks.get(id2);
     if (!waiting) return;
     asks.delete(id2);
     if (error !== void 0) waiting.reject(new Error(error));
     else waiting.resolve(hash);
   };
-  return { lookup: lookup2, answer };
+  return { lookup: lookup2, answer: answer2 };
 }
 
 // src/kernel/net/remote-transport.ts
@@ -28725,14 +28922,14 @@ function sealedAsker(port) {
     port.postMessage({ sealedAsk: { id: id2, req } });
     return waiting.promise.finally(() => signal.removeEventListener("abort", abort));
   };
-  const answer = ({ id: id2, reply, error }) => {
+  const answer2 = ({ id: id2, reply, error }) => {
     const waiting = asks.get(id2);
     if (!waiting) return;
     asks.delete(id2);
     if (reply) waiting.resolve(reply);
     else waiting.reject(new Error(error ?? "no reply"));
   };
-  return { hook, answer };
+  return { hook, answer: answer2 };
 }
 
 // src/serve.ts
@@ -28845,8 +29042,8 @@ function sudoApprovals(port) {
       );
       port.postMessage({ sudoAsk: req });
     }),
-    answer({ id: id2, answer }) {
-      waiting.get(id2)?.(answer);
+    answer({ id: id2, answer: answer2 }) {
+      waiting.get(id2)?.(answer2);
       waiting.delete(id2);
     }
   };
@@ -28940,10 +29137,10 @@ function policyAsker(port) {
   return {
     mountPolicy: (policy) => policy === void 0 ? {} : { processMounts: policy === "ask" ? askPolicy : policy },
     allowed(data) {
-      const answer = data.mountAllowed;
-      if (!answer) return false;
-      policies.get(answer.id)?.(answer.allowed);
-      policies.delete(answer.id);
+      const answer2 = data.mountAllowed;
+      if (!answer2) return false;
+      policies.get(answer2.id)?.(answer2.allowed);
+      policies.delete(answer2.id);
       return true;
     }
   };