@ai-ecoverse/slicc-kernel 1.158.1 → 1.159.1

package/dist/process-worker.js

@@ -236,8 +236,8 @@ function localWait(wait2, blocks = true) {
 function localCpuNanos() {
   if (!local || !localSab) return void 0;
   const now = epochMicros();
-  const blocked = Number(Atomics.load(local, BLOCKED)) + localIdle(localSab, now).idle;
-  return BigInt(Math.max(0, now - localStart - blocked)) * 1000n;
+  const blocked2 = Number(Atomics.load(local, BLOCKED)) + localIdle(localSab, now).idle;
+  return BigInt(Math.max(0, now - localStart - blocked2)) * 1000n;
 }
 function localIdle(sab, now) {
   const state = Number(Atomics.load(slots(sab), IDLE));
@@ -2964,7 +2964,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.158.1" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.159.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -5503,8 +5503,8 @@ var init_process_signals = __esm({
           this.hooks.killed(killed);
         }
         const timers = Atomics.exchange(this.header, SAB_I_TIMERS, 0);
-        const blocked = Atomics.load(this.header, SAB_I_BLOCKED);
-        const pending = blocked === 0 ? Atomics.exchange(this.header, SAB_I_SIGNALS, 0) : Atomics.and(this.header, SAB_I_SIGNALS, blocked) & ~blocked;
+        const blocked2 = Atomics.load(this.header, SAB_I_BLOCKED);
+        const pending = blocked2 === 0 ? Atomics.exchange(this.header, SAB_I_SIGNALS, 0) : Atomics.and(this.header, SAB_I_SIGNALS, blocked2) & ~blocked2;
         if (this.depth <= 1) this.lastDelivered = pending | (timers & 1 ? sigbit(SIG.ALRM) : 0);
         if (pending !== 0 || timers !== 0) this.delivered++;
         this.raised |= pending | (timers & 1 ? sigbit(SIG.ALRM) : 0) | (timers & ~1 ? -1 : 0);
@@ -6554,8 +6554,8 @@ async function runWasmProcess(init, port2, deps = {}) {
   };
   const transport = credSyncTransport(gated, () => early(), init.cred);
   const sys = kernelSys(transport);
-  const encoder5 = new TextEncoder();
-  const say = (fd) => (text) => sys.write(fd, encoder5.encode(`${text}
+  const encoder6 = new TextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder6.encode(`${text}
 `));
   let ready;
   let failed5;
@@ -9997,11 +9997,11 @@ var init_wasi_memory = __esm({
         return at;
       }
       putStrings(list, ptrs, buf) {
-        const encoder5 = new TextEncoder();
+        const encoder6 = new TextEncoder();
         const v = this.view();
         let at = buf;
         list.forEach((s, i) => {
-          const b = encoder5.encode(s);
+          const b = encoder6.encode(s);
           v.setUint32(ptrs + i * 4, at, true);
           this.bytes(at, b.length).set(b);
           v.setUint8(at + b.length, 0);
@@ -10009,12 +10009,12 @@ var init_wasi_memory = __esm({
         });
       }
       putSizes(list, countPtr, sizePtr) {
-        const encoder5 = new TextEncoder();
+        const encoder6 = new TextEncoder();
         const v = this.view();
         v.setUint32(countPtr, list.length, true);
         v.setUint32(
           sizePtr,
-          list.reduce((n, s) => n + encoder5.encode(s).length + 1, 0),
+          list.reduce((n, s) => n + encoder6.encode(s).length + 1, 0),
           true
         );
       }
@@ -12181,7 +12181,7 @@ var init_wasi_threads = __esm({
         this.beforeSpawn?.();
         const tid = Atomics.add(this.ids, LAST_TID, 1) + 1;
         const modules = this.modules?.();
-        const blocked = this.blocked?.();
+        const blocked2 = this.blocked?.();
         this.port.postMessage({
           type: WASM_THREAD_SPAWN,
           thread: {
@@ -12190,7 +12190,7 @@ var init_wasi_threads = __esm({
             memory: this.memory,
             ids: this.ids.buffer,
             ...modules ? { modules } : {},
-            ...anyBlocked(blocked) ? { blocked } : {}
+            ...anyBlocked(blocked2) ? { blocked: blocked2 } : {}
           }
         });
         return tid;
@@ -16983,6 +16983,13 @@ function resetOf(kernel, fd, closed, close) {
     await close();
   };
 }
+function adoptOf(kernel, connection, listening, name2) {
+  return async (fd) => {
+    const req = { op: "sock-getopt", fd, level: SOL_SOCKET2, name: SO_ACCEPTCONN };
+    if (await kernel.json(req) !== 1) return connection(fd);
+    return listening(fd, await name2(fd, false));
+  };
+}
 function netOps(kernel, io, sync) {
   const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
@@ -17104,11 +17111,6 @@ function netOps(kernel, io, sync) {
     });
     return [...r.ok && r.kind === "json" ? r.json : []];
   };
-  const inetAt = (options) => ({
-    family: "inet",
-    host: options.host ?? "127.0.0.1",
-    port: port(options.port ?? 0)
-  });
   const listenSync = (options = {}) => {
     const lane = sync;
     const addr = inetAt(options);
@@ -17128,6 +17130,7 @@ function netOps(kernel, io, sync) {
   return {
     sync: { listen: listenSync },
     resolve: lookup2,
+    adopt: adoptOf(kernel, connection, listener, name2),
     listen: async (options = {}) => {
       const tls = options.tls ? serveRequest(options.tls) : void 0;
       return opened2(async (fd) => {
@@ -17150,7 +17153,7 @@ function netOps(kernel, io, sync) {
     }
   };
 }
-var PEM, TLS_CODE, ALERT, SHUT_RD, SHUT_WR, LOOPBACK3, IPV4, NEVER, SOL_SOCKET2, SO_ERROR2, ALERTS, HANDSHAKE_TIMEOUT_MS, HANDSHAKES_MAX;
+var PEM, TLS_CODE, ALERT, SHUT_RD, SHUT_WR, LOOPBACK3, IPV4, NEVER, SOL_SOCKET2, SO_ERROR2, SO_ACCEPTCONN, ALERTS, HANDSHAKE_TIMEOUT_MS, HANDSHAKES_MAX, inetAt;
 var init_js_net = __esm({
   "src/process/js/js-net.ts"() {
     "use strict";
@@ -17166,6 +17169,7 @@ var init_js_net = __esm({
     NEVER = new AbortController().signal;
     SOL_SOCKET2 = 1;
     SO_ERROR2 = 4;
+    SO_ACCEPTCONN = 30;
     ALERTS = {
       unrecognized_name: 112,
       no_application_protocol: 120,
@@ -17175,6 +17179,11 @@ var init_js_net = __esm({
     };
     HANDSHAKE_TIMEOUT_MS = 12e4;
     HANDSHAKES_MAX = 64;
+    inetAt = (options) => ({
+      family: "inet",
+      host: options.host ?? "127.0.0.1",
+      port: port(options.port ?? 0)
+    });
   }
 });
 
@@ -17327,6 +17336,69 @@ var init_js_proc = __esm({
   }
 });
 
+// src/process/js/js-rights.ts
+function sendmsgRequest(fd, data, options = {}) {
+  return {
+    op: "sock-sendmsg",
+    fd,
+    body: typeof data === "string" ? encoder2.encode(data) : data,
+    fds: options.fds ?? [],
+    nonblock: options.nonblock === true
+  };
+}
+function recvmsgRequest(fd, max = RECV_DEFAULT, options = {}) {
+  return {
+    op: "sock-recvmsg",
+    fd,
+    max,
+    cloexec: options.cloexec === true,
+    nonblock: options.nonblock === true
+  };
+}
+function decodeReceived2(frame) {
+  const view = new DataView(frame.buffer, frame.byteOffset, frame.byteLength);
+  const count = view.getUint32(0, true);
+  const fds = [];
+  for (let i = 0; i < count; i++) fds.push(view.getUint32(8 + i * 4, true));
+  return {
+    bytes: frame.slice(8 + count * 4),
+    fds,
+    ctrunc: (view.getUint32(4, true) & 1) === 1
+  };
+}
+async function blocked(kernel, watch, req) {
+  if (req.nonblock) return kernel.call(req);
+  const { signal, done } = watch(req.fd);
+  try {
+    return await kernel.blocking(req, signal);
+  } finally {
+    done();
+  }
+}
+function rightsAsync(kernel, forget, watch) {
+  return {
+    socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    sendmsg: async (fd, data, options) => jsonOf(await blocked(kernel, watch, sendmsgRequest(fd, data, options))),
+    async recvmsg(fd, max, options) {
+      const got = decodeReceived2(
+        bytesOf2(await blocked(kernel, watch, recvmsgRequest(fd, max, options)))
+      );
+      for (const n of got.fds) forget(n);
+      return got;
+    }
+  };
+}
+var jsonOf, bytesOf2, encoder2, RECV_DEFAULT;
+var init_js_rights = __esm({
+  "src/process/js/js-rights.ts"() {
+    "use strict";
+    jsonOf = (r) => r.ok && r.kind === "json" ? r.json : void 0;
+    bytesOf2 = (r) => r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(8);
+    encoder2 = new TextEncoder();
+    RECV_DEFAULT = 64 * 1024;
+  }
+});
+
 // src/process/js/js-run.ts
 function stdioOf(how) {
   if (how === void 0) return "pipe";
@@ -17364,7 +17436,7 @@ function runSync(kernel, d, o) {
   const named = argv0Of(o.argv0, "run");
   const stdout = stdioOf(o.stdout);
   const stderr = stderrOf(o.stderr);
-  const input = typeof o.input === "string" ? encoder2.encode(o.input) : o.input;
+  const input = typeof o.input === "string" ? encoder3.encode(o.input) : o.input;
   const maxBuffer = limit(o.maxBuffer);
   const timeout = limit(o.timeout);
   const bytes = kernel.bytes({
@@ -17387,13 +17459,13 @@ function runSync(kernel, d, o) {
   });
   return decodeRun(bytes, stdout, stderr);
 }
-var encoder2, STDIO4;
+var encoder3, STDIO4;
 var init_js_run = __esm({
   "src/process/js/js-run.ts"() {
     "use strict";
     init_js_children();
     init_js_kernel();
-    encoder2 = new TextEncoder();
+    encoder3 = new TextEncoder();
     STDIO4 = /* @__PURE__ */ new Set(["pipe", "ignore", "inherit"]);
   }
 });
@@ -17451,7 +17523,7 @@ function syncOps(kernel, shared) {
     return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
   };
   const write2 = (fd, data, options) => {
-    const bytes = typeof data === "string" ? encoder3.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
     const i = info(fd);
     if (writeDevice(i)) return bytes.length;
     const nonblock = options?.nonblock === true;
@@ -17542,6 +17614,12 @@ function syncOps(kernel, shared) {
       kernel.call({ op: "fd-close", fd });
     },
     socketpair: () => kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    sendmsg: (fd, data, options) => kernel.json(sendmsgRequest(fd, data, options)),
+    recvmsg(fd, max, options) {
+      const got = decodeReceived2(kernel.bytes(recvmsgRequest(fd, max, options)));
+      for (const n of got.fds) infos.delete(n);
+      return got;
+    },
     pipe: () => kernel.json({ op: "fd-pipe" }),
     open: procOpenSync(open, kernel, { resolve, pid: shared.pid }),
     fs: procFsSync(syncPathOps(kernel, resolve, statOf, open, tryDevSync), kernel, {
@@ -17688,14 +17766,14 @@ function syncPathOps(kernel, resolve, statOf, open, tryDev) {
         ...mode !== void 0 ? { mode } : {}
       });
       try {
-        file.write(0, typeof data === "string" ? encoder3.encode(data) : data);
+        file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
       } finally {
         file.close();
       }
     }
   };
 }
-var encoder3, noLane, READ_ONLY, JsSyncKernel;
+var encoder4, noLane, READ_ONLY, JsSyncKernel;
 var init_js_sync = __esm({
   "src/process/js/js-sync.ts"() {
     "use strict";
@@ -17707,7 +17785,8 @@ var init_js_sync = __esm({
     init_js_io();
     init_js_kernel();
     init_js_proc();
-    encoder3 = new TextEncoder();
+    init_js_rights();
+    encoder4 = new TextEncoder();
     noLane = () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
     READ_ONLY = /* @__PURE__ */ new Set([...SYNC_FS_READ_ONLY, "fd-path-flush"]);
     JsSyncKernel = class {
@@ -18622,13 +18701,23 @@ function pendingReads(kernel, info, random) {
     for (const stop of reading.get(fd) ?? []) stop.abort(new JsCallError("EBADF", "read"));
     reading.delete(fd);
   };
-  return { read: read2, closing };
+  const watch = (fd) => {
+    const stop = new AbortController();
+    const waits = reading.get(fd) ?? /* @__PURE__ */ new Set();
+    reading.set(fd, waits.add(stop));
+    const done = () => {
+      waits.delete(stop);
+      if (waits.size === 0 && reading.get(fd) === waits) reading.delete(fd);
+    };
+    return { signal: stop.signal, done };
+  };
+  return { read: read2, closing, watch };
 }
 function tracked2(pending, writeAll, writeSome, failed5) {
   return (fd, data, options) => {
     const status2 = failed5?.();
     if (status2 !== void 0) return Promise.reject(new JsExit(status2));
-    const bytes = typeof data === "string" ? encoder4.encode(data) : data;
+    const bytes = typeof data === "string" ? encoder5.encode(data) : data;
     let settle;
     const settled2 = new Promise((resolve) => settle = resolve);
     pending.add(settled2);
@@ -18658,6 +18747,12 @@ function measured(measure) {
   }
   return out;
 }
+function realmOps(o) {
+  return {
+    runScript: scriptRunner(o.runScript),
+    promiseState: (promise) => o.promiseState?.(promise)
+  };
+}
 function scriptRunner(run) {
   return (source, options = {}) => {
     if (typeof source !== "string") throw new TypeError("runScript needs a source string");
@@ -18698,7 +18793,7 @@ function createContext(o) {
     infos.set(fd, got);
     return got;
   };
-  const { read: read2, closing } = pendingReads(kernel, info, random);
+  const { read: read2, closing, watch } = pendingReads(kernel, info, random);
   const { writes, writeAll, writeSome } = writer(kernel, info, o.pid);
   const write2 = tracked2(pending, writeAll, writeSome, o.failed);
   const writable2 = (fd) => new WritableStream({
@@ -18752,7 +18847,7 @@ function createContext(o) {
     cred: () => syncKernel.json({ op: "proc-cred" }),
     umask: (mask) => syncKernel.json(umaskRequest(mask)),
     setcred: setcredOn(syncKernel),
-    runScript: scriptRunner(o.runScript)
+    ...realmOps(o)
   };
   const io = { read: read2, send: writeAll, close: (fd) => ctx.close(fd) };
   const defaults = { env: o.env, cwd: o.cwd, signal: signalNumber };
@@ -18778,7 +18873,7 @@ function createContext(o) {
       closing(fd);
       await kernel.call({ op: "fd-close", fd });
     },
-    socketpair: async () => await kernel.json({ op: "sock-pair", domain: "unix", type: "stream" }),
+    ...rightsAsync(kernel, (fd) => infos.delete(fd), watch),
     pipe: async () => await kernel.json({ op: "fd-pipe" }),
     select: (sets, options) => selectOp(kernel, sets, options?.signal),
     async fdStatus(fd) {
@@ -19008,14 +19103,14 @@ function pathOps(kernel, resolve, statOf, open, tryDev) {
         true
       );
       try {
-        await file.write(0, typeof data === "string" ? encoder4.encode(data) : data);
+        await file.write(0, typeof data === "string" ? encoder5.encode(data) : data);
       } finally {
         await file.close();
       }
     }
   };
 }
-var KERNEL_INFO, JsExit, encoder4, cryptoRandom, MEMORY_FIELDS;
+var KERNEL_INFO, JsExit, encoder5, cryptoRandom, MEMORY_FIELDS;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
@@ -19033,6 +19128,7 @@ var init_js_context = __esm({
     init_js_kernel();
     init_js_net();
     init_js_proc();
+    init_js_rights();
     init_js_run();
     init_js_sync();
     init_js_tty();
@@ -19048,7 +19144,7 @@ var init_js_context = __esm({
         this.status = status2;
       }
     };
-    encoder4 = new TextEncoder();
+    encoder5 = new TextEncoder();
     cryptoRandom = (bytes) => void crypto.getRandomValues(bytes);
     MEMORY_FIELDS = [
       "heapUsed",
@@ -19234,6 +19330,7 @@ async function runJs(init, port2, deps, thread) {
     memory: deps.memory,
     asyncContext: deps.asyncContext,
     runScript: deps.runScript,
+    promiseState: deps.promiseState,
     ...thread?.owned ? { owned: thread.owned } : {},
     held: init.held,
     failed: () => failedWith