@ai-ecoverse/slicc-kernel 1.27.0 → 1.29.0

package/dist/index.js

@@ -282,6 +282,101 @@ async function loopbackFetch(dial, input, options) {
   }
 }
 
+// src/kernel/net/loopback-names.ts
+var HOST_LOOPBACK = "host.slicc.internal";
+var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
+var PAGE_LOOPBACK = "kernel.localhost";
+var PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
+
+// src/kernel/net/routes.ts
+var HOST_ADDRESS = HOST_LOOPBACK_ADDRESS.join(".");
+function ipv4Bytes(text) {
+  const parts = text.split(".");
+  if (parts.length !== 4 || !parts.every((p) => /^\d{1,3}$/.test(p))) return void 0;
+  const bytes = parts.map(Number);
+  return bytes.every((b) => b <= 255) ? bytes : void 0;
+}
+function ipv6Groups(text) {
+  if (!text.includes(":")) return void 0;
+  let canonical;
+  try {
+    canonical = new URL(`http://[${text}]/`).hostname.slice(1, -1);
+  } catch {
+    return void 0;
+  }
+  const [head, tail] = canonical.split("::");
+  const part = (s) => s ? s.split(":").map((h) => Number.parseInt(h, 16)) : [];
+  const front = part(head);
+  const back = part(tail);
+  return tail === void 0 ? front : [...front, ...new Array(8 - front.length - back.length).fill(0), ...back];
+}
+function toBits(values, width) {
+  return values.reduce((acc, v) => acc << BigInt(width) | BigInt(v), 0n);
+}
+function addressBits(host) {
+  const v4 = ipv4Bytes(host);
+  if (v4) return { v6: false, bits: toBits(v4, 8) };
+  const v6 = ipv6Groups(host);
+  return v6 ? { v6: true, bits: toBits(v6, 16) } : void 0;
+}
+function parsePrefix(text) {
+  const parts = text.trim().split("/");
+  if (parts.length > 2) return void 0;
+  const [address = "", size] = parts;
+  const parsed = addressBits(address);
+  if (!parsed) return void 0;
+  const max = parsed.v6 ? 128 : 32;
+  const length = size === void 0 ? max : /^\d{1,3}$/.test(size) ? Number(size) : -1;
+  if (length < 0 || length > max) return void 0;
+  return { ...parsed, length };
+}
+function within(prefix, addr) {
+  if (prefix.v6 !== addr.v6) return false;
+  const shift = BigInt((prefix.v6 ? 128 : 32) - prefix.length);
+  return addr.bits >> shift === prefix.bits >> shift;
+}
+var RESERVED = [
+  "0.0.0.0/8",
+  "127.0.0.0/8",
+  "169.254.0.0/16",
+  "224.0.0.0/4",
+  "240.0.0.0/4",
+  "::/96",
+  "::ffff:0:0/96",
+  "fe80::/10",
+  "ff00::/8"
+].map((p) => parsePrefix(p));
+var Routes = class {
+  table = [];
+  exit = false;
+  ipv6;
+  constructor(ipv6 = false) {
+    this.ipv6 = ipv6;
+  }
+  set(table) {
+    const parsed = (table.prefixes ?? []).map(parsePrefix);
+    const bad = (table.prefixes ?? []).find((_, i) => !parsed[i]);
+    if (bad !== void 0) throw new Error(`not an address prefix: ${bad}`);
+    this.table = parsed;
+    this.exit = table.exit === true;
+  }
+  classify(host) {
+    const name = host.toLowerCase().replace(/\.$/, "");
+    if (name === "localhost" || name.endsWith(".localhost") || name === "0.0.0.0") {
+      return "loopback";
+    }
+    if (name === HOST_LOOPBACK || name === HOST_ADDRESS) return "host";
+    const addr = addressBits(name);
+    if (!addr) return "unreachable";
+    if (addr.v6 && addr.bits === 1n) return "loopback";
+    if (!addr.v6 && addr.bits >> 24n === 127n) return "loopback";
+    if (RESERVED.some((p) => within(p, addr))) return "reserved";
+    if (addr.v6 && !this.ipv6) return "unreachable";
+    if (this.exit || this.table.some((p) => within(p, addr))) return "uplink";
+    return "unreachable";
+  }
+};
+
 // src/kernel/net/uplink.ts
 function answerOf(result) {
   const answer = Array.isArray(result) ? { addresses: result } : result;
@@ -300,30 +395,90 @@ function failure(uid, e) {
     ...typeof code === "string" ? { code } : {}
   };
 }
+var NEVER = new Routes(true);
 function serveUplink(peer, uplink) {
+  const conns = /* @__PURE__ */ new Map();
   const pending = /* @__PURE__ */ new Map();
-  const answer = (call) => {
-    if (call.uplink === "cancel") return pending.get(call.uid)?.abort();
+  let nextCid = 0;
+  let closed = false;
+  const run = (uid, work) => {
     const abort = new AbortController();
-    pending.set(call.uid, abort);
-    void (async () => {
-      try {
-        const answer2 = answerOf(await uplink.resolve(call.name, call.family, abort.signal));
-        peer.postMessage({ uplink: "resolved", uid: call.uid, ...answer2 });
-      } catch (e) {
-        peer.postMessage(failure(call.uid, e));
-      } finally {
-        pending.delete(call.uid);
-      }
-    })();
+    pending.set(uid, abort);
+    void work(abort.signal).then(
+      (reply) => reply && peer.postMessage(reply, transferOf(reply)),
+      (e) => peer.postMessage(failure(uid, e))
+    ).finally(() => pending.delete(uid));
+  };
+  const conn = (cid) => {
+    const found = conns.get(cid);
+    if (!found) throw Object.assign(new Error("no such uplink connection"), { code: "EBADF" });
+    return found;
+  };
+  const dial = async (call, signal) => {
+    const kind = NEVER.classify(call.host);
+    if (kind === "loopback" || kind === "host" || kind === "reserved") {
+      throw Object.assign(new Error(`the uplink does not carry ${call.host}`), {
+        code: "ENETUNREACH"
+      });
+    }
+    const { host, port } = call;
+    const opened = await uplink.dial({ network: "tcp", host, port, signal });
+    if (signal.aborted || closed) {
+      opened.close();
+      return void 0;
+    }
+    const cid = ++nextCid;
+    conns.set(cid, opened);
+    const { localAddr, remoteAddr } = opened;
+    return { uplink: "dialled", uid: call.uid, cid, localAddr, remoteAddr };
+  };
+  const drop = (cid) => {
+    const found = conns.get(cid);
+    conns.delete(cid);
+    found?.close();
   };
   return {
-    answer,
-    close: () => {
+    answer(call) {
+      switch (call.uplink) {
+        case "resolve":
+          return run(call.uid, async (signal) => ({
+            uplink: "resolved",
+            uid: call.uid,
+            ...answerOf(await uplink.resolve(call.name, call.family, signal))
+          }));
+        case "dial":
+          return run(call.uid, (signal) => dial(call, signal));
+        case "cancel":
+          return pending.get(call.uid)?.abort();
+        case "read":
+          return run(call.uid, async () => ({
+            uplink: "data",
+            uid: call.uid,
+            bytes: (await conn(call.cid).read())?.slice() ?? null
+          }));
+        case "write":
+          return run(call.uid, async () => ({
+            uplink: "written",
+            uid: call.uid,
+            n: await conn(call.cid).write(call.bytes)
+          }));
+        case "close-write":
+          return conns.get(call.cid)?.closeWrite();
+        default:
+          return drop(call.cid);
+      }
+    },
+    close() {
+      closed = true;
       for (const abort of pending.values()) abort.abort();
+      for (const cid of [...conns.keys()]) drop(cid);
     }
   };
 }
+function transferOf(reply) {
+  if (reply.uplink !== "data" || !reply.bytes) return void 0;
+  return [reply.bytes.buffer];
+}
 
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
@@ -604,7 +759,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 6];
+var PROTOCOL = [1, 7];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;