@ai-ecoverse/slicc-kernel 1.90.0 → 1.91.0

package/dist/node-process-worker.js

@@ -2305,34 +2305,40 @@ function readyEvents(subs, ready) {
     hangup: ready.hangup?.includes(s.fd) === true
   }));
 }
+function selectOnce(deps, read2, write2, timeoutMs) {
+  try {
+    const ready = deps.kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
+    return { ready, interrupted: false };
+  } catch (e) {
+    if (!deps.interruptWakes || e.code !== "EINTR") throw e;
+    return { ready: { read: [], write: [] }, interrupted: true };
+  }
+}
+function waitEvents(deps, subs, { events, read: read2, write: write2 }, entered) {
+  const earliest = subs.reduce((min, s) => Math.min(min, s.deadline), Infinity);
+  const timeout = () => {
+    if (events.length > 0 || entered) return 0;
+    return earliest === Infinity ? -1 : Math.max(0, Math.ceil(earliest - performance.now()));
+  };
+  for (; ; ) {
+    const { ready, interrupted } = selectOnce(deps, read2, write2, timeout());
+    events.push(...readyEvents(subs, ready));
+    if (interrupted) return true;
+    if (events.length > 0 || entered || earliest === Infinity) return false;
+    if (performance.now() >= earliest) return false;
+  }
+}
 function pollOneoff(deps, inPtr, outPtr, nsubs, neventsPtr) {
   if (nsubs === 0) return E.INVAL;
-  const { mem, kernel } = deps;
+  const { mem } = deps;
   const subs = readSubscriptions(mem, inPtr, nsubs, deps.now);
-  const { events, read: read2, write: write2 } = classify(deps.fds, subs);
-  let interrupted = false;
-  const earliest = subs.reduce((min, s) => Math.min(min, s.deadline), Infinity);
-  const expired = () => performance.now() >= earliest;
-  if (read2.length > 0 || write2.length > 0 || events.length === 0) {
-    do {
-      let timeoutMs = -1;
-      if (events.length > 0) timeoutMs = 0;
-      else if (earliest !== Infinity)
-        timeoutMs = Math.max(0, Math.ceil(earliest - performance.now()));
-      let ready;
-      try {
-        ready = kernel.call({ op: "fd-select", read: read2, write: write2, timeoutMs });
-      } catch (e) {
-        if (!deps.interruptWakes || e.code !== "EINTR") throw e;
-        interrupted = true;
-        ready = { read: [], write: [] };
-      }
-      events.push(
-        ...readyEvents(subs, ready)
-      );
-    } while (events.length === 0 && !interrupted && earliest !== Infinity && !expired());
-  }
+  const found = classify(deps.fds, subs);
+  const { events, read: read2, write: write2 } = found;
+  const entered = deps.entered === true && deps.interruptWakes !== true;
+  const waits = read2.length > 0 || write2.length > 0 || events.length === 0;
+  const interrupted = waits && waitEvents(deps, subs, found, entered);
   const after = performance.now();
+  if (entered && events.length === 0 && !subs.some((s) => s.deadline <= after)) return E.INTR;
   for (const s of subs) {
     if (s.type === EVENTTYPE.CLOCK && (interrupted || s.deadline <= after)) {
       events.push({ userdata: s.userdata, error: E.SUCCESS, type: s.type });
@@ -2538,6 +2544,7 @@ var init_wasi_host = __esm({
       cache;
       startCwd;
       interruptWakes = false;
+      entered = false;
       onRaise;
       muted;
       signals;
@@ -2761,7 +2768,8 @@ var init_wasi_host = __esm({
               fds: this.fds,
               kernel: this.o.kernel,
               now: (id) => this.now(id),
-              interruptWakes: this.interruptWakes
+              interruptWakes: this.interruptWakes,
+              entered: this.entered
             },
             inPtr,
             outPtr,
@@ -2778,7 +2786,7 @@ var init_wasi_host = __esm({
           this.mem.view().setUint32(nevents, 0, true);
           if (mask.deliverUnblocked()) return E.INTR;
           if (n > 0) return this.poll(inPtr, outPtr, n, nevents);
-          return this.suspend();
+          return this.entered ? E.INTR : this.suspend();
         } finally {
           mask.deliverUnblocked();
           mask.restore(old);
@@ -3876,7 +3884,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.90.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.91.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -4812,6 +4820,52 @@ var init_js_exit = __esm({
   }
 });
 
+// src/kernel/net/loopback-names.ts
+function isKernelLoopbackHost(hostname) {
+  const host = hostname.replace(/^\[(.*)\]$/, "$1").replace(/\.$/, "").toLowerCase();
+  return host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0" || LOOPBACK_V4.test(host) || LOOPBACK_V6.has(host) || MAPPED_V4.test(host);
+}
+function reserved(name2) {
+  const lower = name2.toLowerCase();
+  return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
+}
+function isHostname(name2) {
+  if (typeof name2 !== "string" || name2.length > 253 || reserved(name2)) return false;
+  return name2.split(".").every((l) => LABEL.test(l));
+}
+function hostnameOf(env) {
+  return isHostname(env.HOSTNAME) ? env.HOSTNAME : DEFAULT_HOSTNAME;
+}
+function ownNames(hostname) {
+  return [.../* @__PURE__ */ new Set([hostname.toLowerCase(), ...LIBC_HOSTNAMES])];
+}
+function hostsFile(hostname = DEFAULT_HOSTNAME) {
+  return [
+    "127.0.0.1 localhost localhost.localdomain",
+    "::1 localhost ip6-localhost",
+    `${HOSTNAME_ADDRESS} ${ownNames(hostname).join(" ")}`,
+    `${HOST_LOOPBACK_ADDRESS.join(".")} ${HOST_LOOPBACK}`,
+    ""
+  ].join("\n");
+}
+var HOST_LOOPBACK, HOST_LOOPBACK_ADDRESS, PAGE_LOOPBACK, PAGE_LOOPBACK_URL, LOOPBACK_V4, LOOPBACK_V6, MAPPED_V4, DEFAULT_HOSTNAME, HOSTNAME_ADDRESS, LIBC_HOSTNAMES, LABEL;
+var init_loopback_names = __esm({
+  "src/kernel/net/loopback-names.ts"() {
+    "use strict";
+    HOST_LOOPBACK = "host.slicc.internal";
+    HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
+    PAGE_LOOPBACK = "kernel.localhost";
+    PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
+    LOOPBACK_V4 = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+    LOOPBACK_V6 = /* @__PURE__ */ new Set(["::1", "::", "0:0:0:0:0:0:0:1"]);
+    MAPPED_V4 = /^::ffff:7f[0-9a-f]{2}:[0-9a-f]{1,4}$/;
+    DEFAULT_HOSTNAME = "slicc";
+    HOSTNAME_ADDRESS = "127.0.1.1";
+    LIBC_HOSTNAMES = ["emscripten", "wasmer.sh"];
+    LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
+  }
+});
+
 // src/process/js/js-fetch.ts
 function withoutFragment(url) {
   url.hash = "";
@@ -4826,11 +4880,20 @@ function plain(status2, text) {
     headers: { "content-type": "text/plain; charset=utf-8" }
   });
 }
+function local2(url) {
+  return isKernelLoopbackHost(new URL(url).hostname);
+}
 function rewrite(hop, status2, location) {
   const next2 = new URL(location, hop.url);
   if (next2.protocol !== "http:" && next2.protocol !== "https:") {
     throw failed(new JsCallError("EPROTONOSUPPORT", next2.protocol));
   }
+  if (local2(next2.href) && !local2(hop.url)) {
+    const from = new URL(hop.url).origin;
+    throw failed(
+      new JsCallError("EACCES", `a redirect from ${from} into the kernel's loopback: ${next2.href}`)
+    );
+  }
   const toGet = (status2 === 301 || status2 === 302) && hop.method === "POST" || status2 === 303 && hop.method !== "GET" && hop.method !== "HEAD";
   const crossOrigin = next2.origin !== new URL(hop.url).origin;
   const headers = hop.headers.filter(
@@ -4999,13 +5062,15 @@ async function bodyOf(request, cap, signal) {
   return out;
 }
 function fetchOp(kernel) {
-  let traits;
-  const traitsOf = () => {
-    traits ??= kernel.json({ op: "net-traits" });
-    traits.catch(() => {
-      traits = void 0;
+  const traits = /* @__PURE__ */ new Map();
+  const traitsOf = (url) => {
+    const own = local2(url);
+    const known = traits.get(own) ?? kernel.json({ op: "net-traits", url });
+    traits.set(own, known);
+    known.catch(() => {
+      traits.delete(own);
     });
-    return traits;
+    return known;
   };
   const close = (handle) => kernel.raw({ op: "net-close", handle });
   const send = async (hop, signal) => {
@@ -5092,6 +5157,13 @@ function fetchOp(kernel) {
     });
     return withMeta(response, head.url, redirected);
   };
+  const traitsAt = (at) => traitsOf(at).catch((err) => {
+    throw failed(err);
+  });
+  const redirect = async (hop, status2, location, known) => {
+    const next2 = rewrite(hop, status2, location);
+    return [next2, local2(next2.url) === local2(hop.url) ? known : await traitsAt(next2.url)];
+  };
   return async (input, init) => {
     const request = new Request(input, init);
     const { signal } = request;
@@ -5101,9 +5173,7 @@ function fetchOp(kernel) {
     if (protocol !== "http:" && protocol !== "https:") {
       throw failed(new JsCallError("EPROTONOSUPPORT", protocol));
     }
-    const known = await traitsOf().catch((err) => {
-      throw failed(err);
-    });
+    let known = await traitsAt(request.url);
     if (!known.manualRedirects && request.redirect !== "follow") {
       throw failed(new JsCallError("ENOTSUP", `redirect: ${request.redirect}`));
     }
@@ -5129,7 +5199,7 @@ function fetchOp(kernel) {
       await close(head.handle);
       if (request.redirect === "error") throw failed(new JsCallError("EREDIRECT", hop.url));
       if (hops >= MAX_REDIRECTS) throw failed(new JsCallError("ELOOP", hop.url));
-      hop = rewrite(hop, head.status, location);
+      [hop, known] = await redirect(hop, head.status, location, known);
     }
   };
 }
@@ -5137,6 +5207,7 @@ var CHUNK2, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTI
 var init_js_fetch = __esm({
   "src/process/js/js-fetch.ts"() {
     "use strict";
+    init_loopback_names();
     init_js_kernel();
     CHUNK2 = 64 * 1024;
     MAX_REDIRECTS = 20;
@@ -5176,7 +5247,7 @@ function port(n) {
 function netOps(kernel, io) {
   const name2 = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
   const connection = async (fd) => {
-    const [local2, remote] = [await name2(fd, false), await name2(fd, true)];
+    const [local3, remote] = [await name2(fd, false), await name2(fd, true)];
     const stop = new AbortController();
     let closed;
     const close = () => {
@@ -5201,7 +5272,7 @@ function netOps(kernel, io) {
       close: async () => void await shut(SHUT_WR),
       abort: () => close()
     });
-    return { fd, local: local2, remote, readable: readable3, writable: writable2, close };
+    return { fd, local: local3, remote, readable: readable3, writable: writable2, close };
   };
   const resolve = async (host, signal) => {
     if (IPV4.test(host)) return host;
@@ -5301,45 +5372,6 @@ var init_js_net = __esm({
   }
 });
 
-// src/kernel/net/loopback-names.ts
-function reserved(name2) {
-  const lower = name2.toLowerCase();
-  return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
-}
-function isHostname(name2) {
-  if (typeof name2 !== "string" || name2.length > 253 || reserved(name2)) return false;
-  return name2.split(".").every((l) => LABEL.test(l));
-}
-function hostnameOf(env) {
-  return isHostname(env.HOSTNAME) ? env.HOSTNAME : DEFAULT_HOSTNAME;
-}
-function ownNames(hostname) {
-  return [.../* @__PURE__ */ new Set([hostname.toLowerCase(), ...LIBC_HOSTNAMES])];
-}
-function hostsFile(hostname = DEFAULT_HOSTNAME) {
-  return [
-    "127.0.0.1 localhost localhost.localdomain",
-    "::1 localhost ip6-localhost",
-    `${HOSTNAME_ADDRESS} ${ownNames(hostname).join(" ")}`,
-    `${HOST_LOOPBACK_ADDRESS.join(".")} ${HOST_LOOPBACK}`,
-    ""
-  ].join("\n");
-}
-var HOST_LOOPBACK, HOST_LOOPBACK_ADDRESS, PAGE_LOOPBACK, PAGE_LOOPBACK_URL, DEFAULT_HOSTNAME, HOSTNAME_ADDRESS, LIBC_HOSTNAMES, LABEL;
-var init_loopback_names = __esm({
-  "src/kernel/net/loopback-names.ts"() {
-    "use strict";
-    HOST_LOOPBACK = "host.slicc.internal";
-    HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
-    PAGE_LOOPBACK = "kernel.localhost";
-    PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
-    DEFAULT_HOSTNAME = "slicc";
-    HOSTNAME_ADDRESS = "127.0.1.1";
-    LIBC_HOSTNAMES = ["emscripten", "wasmer.sh"];
-    LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
-  }
-});
-
 // src/process/wasi-errno.ts
 function wasiErrno(code2) {
   return WASI_ERRNO[code2] ?? E.IO;
@@ -10292,12 +10324,12 @@ function anySelect(Fs, transport, read2, write2, timeoutMs) {
   const kernelRead = read2.filter((fd) => !own(fd));
   const kernelWrite = write2.filter((fd) => !own(fd));
   for (; ; ) {
-    const local2 = ownReady(Fs, read2.filter(own), write2.filter(own));
-    const pending = local2.read.length > 0 || local2.write.length > 0;
+    const local3 = ownReady(Fs, read2.filter(own), write2.filter(own));
+    const pending = local3.read.length > 0 || local3.write.length > 0;
     const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
     const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
     if (typeof got === "number") return got;
-    const ready = { read: [...local2.read, ...got.read], write: [...local2.write, ...got.write] };
+    const ready = { read: [...local3.read, ...got.read], write: [...local3.write, ...got.write] };
     if (ready.read.length > 0 || ready.write.length > 0 || Date.now() >= deadline) {
       return ready;
     }
@@ -13393,10 +13425,8 @@ var init_wasix_host = __esm({
             const v = mem.view();
             const timed = timeoutPtr !== 0 && v.getUint8(timeoutPtr) === 1;
             const ms = timed ? Number(v.getBigUint64(timeoutPtr + 8, true)) / 1e6 : Number.POSITIVE_INFINITY;
-            v.setUint8(
-              wokenPtr,
-              futexWait(i32(), ptr >> 2, expected | 0, ms, host.interrupted) ? 1 : 0
-            );
+            const woken = host.entered || futexWait(i32(), ptr >> 2, expected | 0, ms, host.interrupted);
+            v.setUint8(wokenPtr, woken ? 1 : 0);
           },
           futex_wake: (ptr, wokenPtr) => {
             Atomics.notify(i32(), ptr >> 2, 1);
@@ -13564,9 +13594,10 @@ function delivering(ns, table, host, driver, before) {
     }
     const fn = value2;
     out[name2] = (...args) => {
+      host.entered = false;
       if (driver.idle) {
         before?.();
-        host.interrupted?.();
+        host.entered = host.interrupted?.() === true;
       }
       return fn(...args);
     };