@ai-ecoverse/slicc-kernel 1.171.0 → 1.172.0

package/dist/index.js

@@ -598,6 +598,54 @@ function isHostname(name) {
   return name.split(".").every((l) => LABEL.test(l));
 }
 
+// src/body-idle.ts
+var BODY_IDLE_MS = 5 * 60 * 1e3;
+function idleFailure(ms) {
+  return Object.assign(new Error(`the response body sent no data for ${ms} ms`), {
+    code: "ETIMEDOUT"
+  });
+}
+async function readWithin(reader, ms) {
+  if (!(ms > 0 && ms < Number.POSITIVE_INFINITY)) return reader.read();
+  let timer;
+  const idle = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(idleFailure(ms)), ms);
+  });
+  try {
+    return await Promise.race([reader.read(), idle]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/kernel/net/sealed-fetch.ts
+var SEALED_FETCH_VERSION = 1;
+var UNSAFE_FIELD = /[\r\n\0]/;
+function sealedHooks(option) {
+  if (!option) return {};
+  if (typeof option === "function") return { request: option };
+  const { request, fetch } = option;
+  if (typeof request !== "function" || fetch !== void 0 && typeof fetch !== "function") {
+    throw new TypeError("sealed takes a function or { request, fetch? }");
+  }
+  return { request, ...fetch ? { fetch } : {} };
+}
+function headerList(headers) {
+  return Array.isArray(headers) && headers.every(
+    (field) => Array.isArray(field) && field.length === 2 && field.every((text) => typeof text === "string" && !UNSAFE_FIELD.test(text))
+  );
+}
+function sealedReplyValid(reply) {
+  if (typeof reply !== "object" || reply === null) return false;
+  const { redirects, redirected, status, statusText, headers, url, body, cancel } = reply;
+  return redirects === void 0 && redirected !== true && Number.isInteger(status) && status >= 100 && status <= 599 && typeof statusText === "string" && !UNSAFE_FIELD.test(statusText) && headerList(headers) && (url === void 0 || typeof url === "string") && typeof body?.[Symbol.asyncIterator] === "function" && typeof cancel === "function";
+}
+function dropSealedReply(reply) {
+  const { cancel } = reply ?? {};
+  if (typeof cancel !== "function") return;
+  void Promise.resolve().then(() => cancel.call(reply)).catch(() => void 0);
+}
+
 // src/kernel/net/routes.ts
 var HOST_ADDRESS = HOST_LOOPBACK_ADDRESS.join(".");
 function ipv4Bytes(text) {
@@ -917,8 +965,129 @@ var KERNEL_SIGINFO = Object.freeze({
 });
 
 // src/sealed-relay.ts
-function sealedAnswerer(port, hook) {
+function textOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sendBytes(port, bytes) {
+  const copy = fresh(bytes);
+  port.postMessage({ t: "chunk", bytes: copy }, [copy.buffer]);
+}
+function uploadOf(far) {
+  let waiting;
+  let failure2;
+  const next = () => {
+    if (failure2) return Promise.reject(failure2);
+    waiting = Promise.withResolvers();
+    far.postMessage({ t: "pull" });
+    return waiting.promise;
+  };
+  return {
+    stream: {
+      [Symbol.asyncIterator]: () => ({
+        next,
+        return: async () => {
+          far.postMessage({ t: "stop" });
+          return { value: void 0, done: true };
+        }
+      })
+    },
+    answer(message) {
+      if (message.t === "chunk") waiting?.resolve({ value: message.bytes, done: false });
+      else if (message.t === "end") waiting?.resolve({ value: void 0, done: true });
+      else {
+        failure2 = new Error(message.message);
+        waiting?.reject(failure2);
+      }
+      waiting = void 0;
+    },
+    fail(reason) {
+      failure2 = reason;
+      waiting?.reject(reason);
+      waiting = void 0;
+    }
+  };
+}
+function answerFetch(hook, { req, port: far }, live) {
+  const control = new AbortController();
+  const { streamed, ...fields } = req;
+  const upload = uploadOf(far);
+  let source;
+  let reply;
+  let closed = false;
+  const settle = () => {
+    closed = true;
+    live.delete(answer);
+    upload.fail(new Error("the request ended"));
+  };
+  const answer = {
+    close(reason) {
+      if (closed) return;
+      settle();
+      control.abort(reason);
+      dropSealedReply(reply);
+      far.close();
+    }
+  };
+  const finish = (message) => {
+    if (closed) return;
+    settle();
+    far.postMessage(message);
+  };
+  const failWith = (err) => {
+    dropSealedReply(reply);
+    finish({ t: "error", message: textOf(err) });
+  };
+  const read = async () => {
+    try {
+      const next = await source.next();
+      if (closed) return;
+      if (next.done) finish({ t: "end" });
+      else if (next.value instanceof Uint8Array) sendBytes(far, next.value);
+      else failWith("a body chunk is not bytes");
+    } catch (err) {
+      failWith(err);
+    }
+  };
+  const ask = async () => {
+    try {
+      if (!hook) throw new Error("no vault is connected");
+      const request = {
+        ...fields,
+        ...streamed ? { bodyStream: upload.stream } : {}
+      };
+      const answered = await hook(request, { signal: control.signal });
+      if (!sealedReplyValid(answered)) {
+        dropSealedReply(answered);
+        throw new Error("the reply is not a scrubbed response");
+      }
+      if (closed) return dropSealedReply(answered);
+      reply = answered;
+      source = answered.body[Symbol.asyncIterator]();
+      const { status, statusText, headers, url } = answered;
+      far.postMessage({
+        t: "head",
+        status,
+        statusText,
+        headers,
+        ...url !== void 0 ? { url } : {}
+      });
+    } catch (err) {
+      failWith(err);
+    }
+  };
+  far.addEventListener("message", ({ data }) => {
+    if (data.t === "read") void read();
+    else if (data.t === "cancel") answer.close(data.reason);
+    else upload.answer(data);
+  });
+  far.addEventListener("close", () => answer.close("withdrawn"));
+  far.start();
+  live.add(answer);
+  void ask();
+}
+function sealedAnswerer(port, hook, fetchHook) {
   const asked = /* @__PURE__ */ new Map();
+  const fetches = /* @__PURE__ */ new Set();
   const ask = async ({ id, req }) => {
     const control = new AbortController();
     asked.set(id, control);
@@ -942,36 +1111,18 @@ function sealedAnswerer(port, hook) {
       const message = data;
       if (message?.sealedAsk) void ask(message.sealedAsk);
       else if (message?.sealedAbort) abort(message.sealedAbort);
+      else if (message?.sealedFetch) answerFetch(fetchHook, message.sealedFetch, fetches);
       else return false;
       return true;
     },
     close() {
       for (const control of asked.values()) control.abort("withdrawn");
       asked.clear();
+      for (const answer of [...fetches]) answer.close("withdrawn");
     }
   };
 }
 
-// src/body-idle.ts
-var BODY_IDLE_MS = 5 * 60 * 1e3;
-function idleFailure(ms) {
-  return Object.assign(new Error(`the response body sent no data for ${ms} ms`), {
-    code: "ETIMEDOUT"
-  });
-}
-async function readWithin(reader, ms) {
-  if (!(ms > 0 && ms < Number.POSITIVE_INFINITY)) return reader.read();
-  let timer;
-  const idle = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(idleFailure(ms)), ms);
-  });
-  try {
-    return await Promise.race([reader.read(), idle]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 // src/kernel/net/ws-queue.ts
 var INBOUND_LIMIT = 16 * 1024 * 1024;
 var MESSAGE_LIMIT = 64 * 1024 * 1024;
@@ -1282,7 +1433,21 @@ function headOf(nid, response) {
     headers: response.headers
   };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
+function requestOf(call, signal, uploads) {
+  const { url, method, headers, streamed, body, redirect, nid } = call;
+  return {
+    url,
+    method,
+    headers,
+    ...streamed ? { bodyStream: uploads.of(nid, signal) } : body ? { body } : {},
+    ...redirect !== void 0 ? { redirect } : {},
+    signal
+  };
+}
+function serveTransport(peer, transport, {
+  closeWaitMs = CLOSE_WAIT_MS,
+  attributed = false
+} = {}) {
   const open = /* @__PURE__ */ new Map();
   const fail = (nid, e) => {
     open.delete(nid);
@@ -1302,14 +1467,11 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     const entry = { abort };
     open.set(call.nid, entry);
     try {
-      const response = await transport.fetch({
-        url: call.url,
-        method: call.method,
-        headers: call.headers,
-        ...call.streamed ? { bodyStream: uploads.of(call.nid, abort.signal) } : call.body ? { body: call.body } : {},
-        ...call.redirect !== void 0 ? { redirect: call.redirect } : {},
-        signal: abort.signal
-      });
+      const response = await transport.fetch(
+        requestOf(call, abort.signal, uploads),
+        attributed ? call.owner : void 0,
+        attributed ? call.stamp : void 0
+      );
       if (!open.has(call.nid)) {
         await response.cancel();
         return;
@@ -1564,7 +1726,7 @@ var RemoteTransport = class {
     waiter?.reject(new TransportError("the request was cancelled"));
     this.port.postMessage({ net: "cancel", nid });
   }
-  async fetch(request) {
+  async fetch(request, owner, stamp) {
     const nid = ++this.nextId;
     const { signal, redirect } = request;
     signal.throwIfAborted();
@@ -1594,7 +1756,9 @@ var RemoteTransport = class {
         method: request.method,
         headers: request.headers,
         ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {},
-        ...redirect !== void 0 ? { redirect } : {}
+        ...redirect !== void 0 ? { redirect } : {},
+        ...owner !== void 0 ? { owner } : {},
+        ...stamp ? { stamp } : {}
       });
     } catch (e) {
       finish();
@@ -2279,6 +2443,7 @@ function uplinkInit(uplink) {
   return { uplink: { traits, ...uplink.routes ? { routes: uplink.routes } : {}, ...nameserver } };
 }
 function initCall(options, transport) {
+  const hooks = sealedHooks(options.sealed);
   return {
     op: "init",
     ...options.root ? { root: options.root } : {},
@@ -2297,7 +2462,8 @@ function initCall(options, transport) {
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
     users: options.users === void 0 ? DEFAULT_USERS : options.users,
     ...options.onDenial ? { denials: true } : {},
-    ...options.sealed ? { sealed: true } : {},
+    ...hooks.request ? { sealed: true } : {},
+    ...hooks.fetch ? { sealedFetch: true } : {},
     ...options.clipboard ? { clipboard: true } : {},
     ...options.requests ? { requests: kindsOf(options.requests) } : {},
     ...options.approve ? { approve: true } : {},
@@ -2458,6 +2624,7 @@ function checkOptions(options) {
   if (options.protect) protectInit(options.protect);
   integrityOptions(options.protect?.integrity);
   facadesInit(options.facades);
+  sealedHooks(options.sealed);
 }
 function connector(call, bound) {
   return async (connectOptions = {}) => {
@@ -2474,7 +2641,8 @@ function connector(call, bound) {
   };
 }
 function hookRelays(worker, options, bound) {
-  const sealed = sealedAnswerer(worker, options.sealed);
+  const hooks = sealedHooks(options.sealed);
+  const sealed = sealedAnswerer(worker, hooks.request, hooks.fetch);
   const clipboard = clipboardAnswerer(worker, options.clipboard);
   const integrity = integrityAnswerer(worker, options.protect?.integrity?.lookup);
   const requests = embedderAnswerer(
@@ -2509,6 +2677,17 @@ function traitsUpdater(transport, call) {
     return await call({ op: "transport-traits", ...traits }) === true;
   };
 }
+function transportBridge(worker, transport) {
+  return transport ? serveTransport(worker, transport, { attributed: true }) : void 0;
+}
+function pageOnly(call) {
+  return {
+    sealed: {
+      setPlaceholders: async (list) => void await call({ op: "sealed-placeholders", list })
+    },
+    attest: ((path, options) => call({ op: "attest", path, ...options ? { options } : {} }))
+  };
+}
 async function createKernel(options = {}) {
   checkOptions(options);
   const url = options.worker ?? new URL("./kernel-worker.js", import.meta.url);
@@ -2539,7 +2718,7 @@ async function createKernel(options = {}) {
     pending.clear();
   };
   const transport = options.network?.transport;
-  const bridge = transport ? serveTransport(worker, transport) : void 0;
+  const bridge = transportBridge(worker, transport);
   const uplinks = uplinkServer(worker, options.network?.uplink);
   async function chosen(handle) {
     if (handle) {
@@ -2663,7 +2842,7 @@ async function createKernel(options = {}) {
     umount: async (target) => void await call({ op: "umount", target }),
     mounts: async () => await call({ op: "mounts" }),
     insert: async (target, handle) => void await call({ op: "insert", target, handle }),
-    attest: async (path) => await call({ op: "attest", path }),
+    ...pageOnly(call),
     watch: files.watch,
     terminate() {
       fail(new Error("slicc-kernel terminated"));
@@ -2674,6 +2853,7 @@ async function createKernel(options = {}) {
 export {
   KernelCallError,
   KernelGoneError,
+  SEALED_FETCH_VERSION,
   attachKernel,
   createKernel,
   fetchTransport,