@ai-ecoverse/slicc-kernel 1.170.4 → 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;
@@ -1189,10 +1340,11 @@ function fetchTransport(options = {}) {
   const send = options.fetch ?? globalThis.fetch.bind(globalThis);
   const Socket = options.webSocket === true ? globalThis.WebSocket : options.webSocket || void 0;
   const headers = options.webSocketHeaders === true;
-  const redirect = options.redirect ?? "follow";
+  const instance = options.redirect ?? "follow";
   return {
     traits: {
-      manualRedirects: redirect === "manual",
+      manualRedirects: instance === "manual",
+      redirectPolicy: true,
       encodedBodies: false,
       maxRequestBody: options.maxRequestBody ?? MAX_REQUEST_BODY,
       crossOrigin: "cors",
@@ -1208,7 +1360,7 @@ function fetchTransport(options = {}) {
           headers: joinHeaders(request.headers),
           ...requestBody(request),
           signal: request.signal,
-          redirect,
+          redirect: request.redirect ?? instance,
           credentials: "omit",
           mode: "cors"
         });
@@ -1232,6 +1384,7 @@ function fetchTransport(options = {}) {
       const body = chunks(response.body, options.bodyIdleMs ?? BODY_IDLE_MS);
       return {
         ...response.redirected ? { url: response.url, redirected: true } : {},
+        ...response.type === "opaqueredirect" ? { opaqueRedirect: true } : {},
         status: response.status,
         statusText: response.statusText,
         headers: headers2,
@@ -1267,7 +1420,34 @@ function uploadsFor(peer) {
   });
   return { of, answer: (call) => pulls.get(call.nid)?.(call) };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
+function headOf(nid, response) {
+  return {
+    net: "head",
+    nid,
+    ...response.url !== void 0 ? { url: response.url } : {},
+    ...response.redirected !== void 0 ? { redirected: response.redirected } : {},
+    ...response.redirects ? { redirects: response.redirects } : {},
+    ...response.opaqueRedirect ? { opaqueRedirect: true } : {},
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  };
+}
+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);
@@ -1287,27 +1467,17 @@ 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 } : {},
-        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;
       }
       open.set(call.nid, { abort, body: response.body[Symbol.asyncIterator](), response });
-      peer.postMessage({
-        net: "head",
-        nid: call.nid,
-        ...response.redirected ? { url: response.url, redirected: true } : {},
-        ...response.redirects ? { redirects: response.redirects } : {},
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
+      peer.postMessage(headOf(call.nid, response));
     } catch (e) {
       fail(call.nid, e);
     }
@@ -1461,6 +1631,18 @@ var TransportError = class extends Error {
     this.detail = detail === "transport" ? detail : void 0;
   }
 };
+function unfollowed(redirect) {
+  return redirect !== void 0 && redirect !== "follow";
+}
+function honors(traits, redirect) {
+  if (traits.redirectPolicy === true) return true;
+  const hops = traits.redirectHops;
+  const raw = traits.manualRedirects === true && (hops === void 0 || hops === false);
+  return redirect === "manual" && raw;
+}
+function refused(message) {
+  return new TransportError(message, 502, void 0, "transport");
+}
 var RemoteTransport = class {
   traits;
   port;
@@ -1544,10 +1726,13 @@ 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 } = request;
+    const { signal, redirect } = request;
     signal.throwIfAborted();
+    if (unfollowed(redirect) && !honors(this.traits, redirect)) {
+      throw refused(`this transport cannot honor redirect: ${redirect}`);
+    }
     let finished = false;
     const abort = () => {
       finished = true;
@@ -1570,13 +1755,16 @@ var RemoteTransport = class {
         url: request.url,
         method: request.method,
         headers: request.headers,
-        ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {}
+        ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {},
+        ...redirect !== void 0 ? { redirect } : {},
+        ...owner !== void 0 ? { owner } : {},
+        ...stamp ? { stamp } : {}
       });
     } catch (e) {
       finish();
       throw e;
     }
-    const { status, statusText, headers, url, redirected, redirects } = head;
+    const { status, statusText, headers, url, redirected, redirects, opaqueRedirect } = head;
     const read = async () => {
       if (finished) return void 0;
       const reply = await this.ask({ net: "read", nid }).catch((e) => {
@@ -1592,9 +1780,15 @@ var RemoteTransport = class {
       finish();
       this.cancel(nid);
     };
+    if (unfollowed(redirect) && (redirected || redirects?.length)) {
+      await cancel();
+      throw refused(`this transport followed a redirect despite redirect: ${redirect}`);
+    }
     return {
-      ...redirected ? { url, redirected } : {},
+      ...url !== void 0 ? { url } : {},
+      ...redirected !== void 0 ? { redirected } : {},
       ...redirects ? { redirects } : {},
+      ...opaqueRedirect ? { opaqueRedirect } : {},
       status,
       statusText,
       headers,
@@ -2054,9 +2248,9 @@ async function greet(channel, lock, timeoutMs, requests) {
   } finally {
     clearTimeout(timer);
   }
-  const refused = hello.error ?? versionError(hello.protocol);
-  if (refused) {
-    const error = new Error(refused);
+  const refused2 = hello.error ?? versionError(hello.protocol);
+  if (refused2) {
+    const error = new Error(refused2);
     channel.end(error);
     throw error;
   }
@@ -2249,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 } : {},
@@ -2267,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 } : {},
@@ -2428,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 = {}) => {
@@ -2444,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(
@@ -2479,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);
@@ -2509,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) {
@@ -2633,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"));
@@ -2644,6 +2853,7 @@ async function createKernel(options = {}) {
 export {
   KernelCallError,
   KernelGoneError,
+  SEALED_FETCH_VERSION,
   attachKernel,
   createKernel,
   fetchTransport,