@ai-ecoverse/slicc-kernel 1.31.1 → 1.32.0

package/dist/node.js

@@ -4492,6 +4492,7 @@ var SAB_I_TIMERS = 9;
 var SAB_I_MEMORY = 10;
 var SAB_I_TOTAL_HI = 11;
 var SAB_I_OFFSET_HI = 12;
+var SAB_I_KILLED = 13;
 var U32 = 2 ** 32;
 function storeU53(header3, lo, hi, value) {
   Atomics.store(header3, hi, Math.floor(value / U32));
@@ -7535,6 +7536,7 @@ function isWasmSyscall(req) {
   return typeof op === "string" && SYSCALL_OPS.has(op);
 }
 var MAX_READ = 1024 * 1024;
+var DYING = { ok: false, errno: "EINTR", message: "the process is being killed" };
 var HOSTS_ONLY = new Resolver({ routes: new Routes() });
 var WasmProcess = class {
   exited = false;
@@ -7543,6 +7545,7 @@ var WasmProcess = class {
   ignored = 0;
   inherited = 0;
   interrupt = new AbortController();
+  dying = false;
   execChild;
   execTermsig;
   stopped = 0;
@@ -7575,7 +7578,10 @@ var WasmProcess = class {
   signal(sig) {
     if (this.execChild !== void 0) {
       void Promise.resolve(this.options.kill?.(this.execChild, sig)).catch(() => void 0);
-      return sig === SIG.KILL ? "terminate" : "forward";
+      if (sig !== SIG.KILL) return "forward";
+      if (!this.options.writesBack?.(this.execChild)) return "terminate";
+      this.wake?.();
+      return "forward";
     }
     if (sig === SIG.KILL) return "terminate";
     if (sig === SIG.CONT) this.cont();
@@ -7619,14 +7625,22 @@ var WasmProcess = class {
     this.options.onSyscall?.(req);
     for (; ; ) {
       await this.resumed;
+      if (this.dying) return DYING;
       const stops = this.stops;
       const result = await this.dispatch(req);
+      if (this.dying) return DYING;
       const restart = !result.ok && result.errno === "EINTR" && this.stops !== stops;
       if (restart && !this.options.hasPending?.()) continue;
       await this.resumed;
       return result;
     }
   }
+  die() {
+    if (this.dying) return;
+    this.dying = true;
+    this.interrupt.abort();
+    this.wake?.();
+  }
   async dispatch(req) {
     try {
       if (isFdSyscall(req)) return await this.fdSyscall(req);
@@ -8087,6 +8101,7 @@ var WASM_MAX_THREADS = 256;
 
 // src/kernel/host.ts
 var CRASHED = 70;
+var KILL_GRACE_MS = 2e3;
 var descIds = /* @__PURE__ */ new WeakMap();
 var nextDescId = 1;
 function descId(file) {
@@ -8110,6 +8125,41 @@ function inheritedFds(fds) {
     };
   });
 }
+var Dying = class {
+  ending;
+  timer;
+  busy = 0;
+  finish;
+  start(code, sig, header3, process, finish) {
+    if (this.ending) return;
+    this.ending = { code, sig };
+    this.finish = finish;
+    this.arm();
+    Atomics.store(header3, SAB_I_KILLED, code);
+    process.die();
+  }
+  async serving(work) {
+    this.busy++;
+    clearTimeout(this.timer);
+    try {
+      return await work();
+    } finally {
+      this.busy--;
+      this.arm();
+    }
+  }
+  arm() {
+    clearTimeout(this.timer);
+    if (this.busy === 0 && this.finish) this.timer = setTimeout(this.finish, KILL_GRACE_MS);
+  }
+  clear() {
+    clearTimeout(this.timer);
+  }
+  status(reported) {
+    if (this.ending) return [this.ending.code, this.ending.sig];
+    return [typeof reported === "number" ? reported : CRASHED, void 0];
+  }
+};
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
@@ -8121,6 +8171,7 @@ function spawnWasmProcess(opts) {
     forker: opts.forker,
     fs: opts.fs,
     kill: opts.kill,
+    ...opts.writesBack ? { writesBack: opts.writesBack } : {},
     processes: opts.processes,
     openFiles: opts.openFiles,
     ...opts.nodes ? { nodes: opts.nodes } : {},
@@ -8151,18 +8202,16 @@ function spawnWasmProcess(opts) {
     renamed: (from, to) => holds.renamed(from, to)
   });
   const worker = opts.createWorker();
-  const dispatch2 = async (req) => {
-    if (isWasmSyscall(req)) return process.syscall(req);
-    return dispatchSyncFs(req);
-  };
+  const dying = new Dying();
+  const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process.syscall(req) : dispatchSyncFs(req));
   const responder = attachSyncSabResponder(worker, sab, token, { dispatch: dispatch2 });
-  let settle;
-  const exited = new Promise((resolve) => settle = resolve);
+  const { promise: exited, resolve: settle } = Promise.withResolvers();
   let done4 = false;
   let endedBy;
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    dying.clear();
     endedBy = sig ?? process.execTermsig;
     worker.removeEventListener("message", onMessage);
     worker.removeEventListener("error", onError);
@@ -8178,10 +8227,10 @@ function spawnWasmProcess(opts) {
   };
   const handle = (data) => {
     if (data?.type === WASM_PROCESS_EXIT) {
-      finish(typeof data.code === "number" ? data.code : CRASHED);
+      finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
-      opts.onError?.(String(data.message));
-      finish(CRASHED);
+      if (!dying.ending) opts.onError?.(String(data.message));
+      finish(...dying.status(CRASHED));
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
     }
@@ -8251,7 +8300,10 @@ function spawnWasmProcess(opts) {
   };
   worker.postMessage(init, opts.fork ? [opts.fork.memory.buffer] : []);
   const signal = (sig) => {
-    if (process.signal(sig) === "terminate") finish(sig === SIG.KILL ? 137 : 128 + sig, sig);
+    if (process.signal(sig) !== "terminate") return;
+    const code = sig === SIG.KILL ? 137 : 128 + sig;
+    if (opts.program.abi !== "wasi" || done4) finish(code, sig);
+    else dying.start(code, sig, header3, process, () => finish(code, sig));
   };
   const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
   return {
@@ -8262,7 +8314,8 @@ function spawnWasmProcess(opts) {
     termsig: () => endedBy,
     onState: (listener) => process.onState(listener),
     memory: () => Atomics.load(header3, SAB_I_MEMORY) * 65536,
-    ignoredSignals: (fork) => process.inheritable(fork)
+    ignoredSignals: (fork) => process.inheritable(fork),
+    writesBack: () => opts.program.abi === "wasi" && !done4
   };
 }
 
@@ -10000,6 +10053,7 @@ var Launcher = class {
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
       kill: (target, sig) => this.kill(target, sig),
+      writesBack: (target) => this.processes.get(target)?.writesBack() === true,
       processes: () => ({ boot: this.boot, processes: this.list() }),
       openFiles: this.openFiles,
       nodes: this.nodes,
@@ -11331,6 +11385,17 @@ async function attachKernel(port, options = {}) {
 }
 
 // src/node.ts
+function hostfsFetchOf(options) {
+  const { hostfsFetch, hostfsOrigin } = options;
+  if (hostfsOrigin === void 0) return hostfsFetch ? { hostfsFetch } : {};
+  const base = hostfsFetch ?? ((url, init) => fetch(url, init));
+  return {
+    hostfsFetch: (url, init) => base(url, {
+      ...init,
+      headers: { ...init.headers, Origin: hostfsOrigin }
+    })
+  };
+}
 function nodeTransport() {
   const transport = fetchTransport();
   return { ...transport, traits: { ...transport.traits, crossOrigin: "any" } };
@@ -11406,6 +11471,7 @@ async function createNodeKernel(options = {}) {
     ...options.processMounts !== void 0 ? { processMounts: options.processMounts } : {},
     ...options.fstabRetries ? { fstabRetries: options.fstabRetries } : {},
     ...options.hostfs ? { hostfs: options.hostfs } : {},
+    ...hostfsFetchOf(options),
     ...options.cdp ? { cdp: options.cdp } : {},
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {}
   });