@ai-ecoverse/slicc-kernel 1.171.0 → 1.172.2

package/dist/process-worker.js

@@ -3118,7 +3118,7 @@ var init_version = __esm({
   "src/version.ts"() {
     "use strict";
     init_captured_globals();
-    KERNEL_VERSION = true ? "1.171.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.172.2" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/testing.js

@@ -126,11 +126,11 @@ function fakeCronClock(start = Date.UTC(2026, 0, 1), utc = true) {
     get sleepers() {
       return sleepers.size;
     },
-    sleep(until, signal) {
+    sleep(until2, signal) {
       if (signal.aborted) return Promise.resolve();
       return new Promise((resolve) => {
         const sleeper = {
-          until,
+          until: until2,
           wake: () => {
             sleepers.delete(sleeper);
             signal.removeEventListener("abort", sleeper.wake);
@@ -145,7 +145,7 @@ function fakeCronClock(start = Date.UTC(2026, 0, 1), utc = true) {
         awake = Math.max(0, awake - 1);
         signal.addEventListener("abort", sleeper.wake, { once: true });
         sleepers.add(sleeper);
-        if (until <= now) queueMicrotask(sleeper.ring);
+        if (until2 <= now) queueMicrotask(sleeper.ring);
         else check();
       });
     },
@@ -166,6 +166,223 @@ function fakeCronClock(start = Date.UTC(2026, 0, 1), utc = true) {
   };
 }
 
+// src/kernel/net/placeholder-floor.ts
+var PLACEHOLDER = /fnox_proxy_[0-9a-f]{24}/;
+var ESCAPE = /%([0-9a-f]{2})/gi;
+var BASIC = /\bbasic\b(.*)/is;
+var PERCENT_LAYERS = 8;
+var BASE64_GROUP = 4;
+var PLACEHOLDER_REFUSED = "refused: this request has a sealed placeholder in its URL, a header or a Basic credential, and nothing fills it, so it was not sent";
+var PlaceholderRefused = class extends Error {
+  status = 403;
+  code = "EACCES";
+  constructor(reason = PLACEHOLDER_REFUSED) {
+    super(reason);
+  }
+};
+function holds(text, known) {
+  return PLACEHOLDER.test(text) || known.some((placeholder) => text.includes(placeholder));
+}
+function carries(text, known) {
+  let layer = text;
+  for (let i = 0; i < PERCENT_LAYERS; i++) {
+    if (holds(layer, known)) return true;
+    const next = layer.replace(
+      ESCAPE,
+      (_, hex) => String.fromCharCode(Number.parseInt(hex, 16))
+    );
+    if (next === layer) return false;
+    layer = next;
+  }
+  return holds(layer, known);
+}
+function basicCarries(value, known) {
+  const credential = BASIC.exec(value)?.[1];
+  if (credential === void 0) return false;
+  const letters = credential.replace(/[^A-Za-z0-9+/_-]/g, "").replaceAll("-", "+").replaceAll("_", "/");
+  for (let shift = 0; shift < BASE64_GROUP; shift++) {
+    const part = letters.slice(shift);
+    const whole = part.length % BASE64_GROUP === 1 ? part.slice(0, -1) : part;
+    if (carries(atob(whole), known)) return true;
+  }
+  return false;
+}
+function headersCarry(headers, known) {
+  return headers.some(
+    ([name, value]) => carries(name, known) || carries(name.toLowerCase(), known) || carries(value, known) || basicCarries(value, known)
+  );
+}
+function urlCarries(url, known) {
+  return carries(url, known) || URL.canParse(url) && carries(new URL(url).href, known);
+}
+function detected(request, known) {
+  return urlCarries(request.url, known) || headersCarry(request.headers, known);
+}
+function refuseSocket(request, known) {
+  if (detected(request, known) || request.protocols.some((p) => carries(p, known))) {
+    throw new PlaceholderRefused();
+  }
+}
+function placeholderFloor(inner, { known = () => [], fill } = {}) {
+  const open = inner.websocket?.bind(inner);
+  return {
+    get traits() {
+      return inner.traits;
+    },
+    ...open ? {
+      websocket: async (request) => {
+        refuseSocket(request, known());
+        return open(request);
+      }
+    } : {},
+    async fetch(request, owner, stamp) {
+      if (!detected(request, known())) return inner.fetch(request, owner, stamp);
+      if (!fill || !stamp) throw new PlaceholderRefused();
+      return fill(request, stamp);
+    }
+  };
+}
+
+// src/body-idle.ts
+var BODY_IDLE_MS = 5 * 60 * 1e3;
+
+// src/kernel/net/sealed-fetch.ts
+var UNSAFE_FIELD = /[\r\n\0]/;
+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);
+}
+function failed(reason) {
+  const text = reason instanceof Error ? reason.message : String(reason);
+  return new PlaceholderRefused(
+    `refused: the request with a sealed placeholder was not completed: ${text}`
+  );
+}
+var Stall = class {
+  idle = new AbortController();
+  ms;
+  timer;
+  signal;
+  constructor(signals, ms) {
+    this.ms = ms;
+    this.signal = AbortSignal.any([...signals, this.idle.signal]);
+  }
+  arm() {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.idle.abort("timeout"), this.ms);
+    this.timer.unref?.();
+  }
+  touch() {
+    if (this.timer !== void 0) this.arm();
+  }
+  rest() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+};
+async function until(work, signal) {
+  const stopped = Promise.withResolvers();
+  const stop = () => stopped.reject(signal.reason);
+  if (signal.aborted) stop();
+  else signal.addEventListener("abort", stop, { once: true });
+  try {
+    return await Promise.race([work, stopped.promise]);
+  } finally {
+    signal.removeEventListener("abort", stop);
+  }
+}
+async function* ticking(stream, stall) {
+  for await (const chunk of stream) {
+    stall.touch();
+    yield chunk;
+  }
+}
+function sealedRequest(request, stamp, stall) {
+  const { method, url, headers, body, bodyStream } = request;
+  return {
+    v: 1,
+    caller: structuredClone(stamp),
+    method,
+    url,
+    headers: headers.map(([name, value]) => [name, value]),
+    redirect: "manual",
+    ...bodyStream ? { bodyStream: ticking(bodyStream, stall) } : body ? { body } : {}
+  };
+}
+function guarded(reply, stall) {
+  let finished = false;
+  const cancel = async () => {
+    stall.signal.removeEventListener("abort", dropped);
+    stall.rest();
+    if (finished) return;
+    finished = true;
+    await reply.cancel().catch(() => void 0);
+  };
+  const dropped = () => void cancel();
+  stall.signal.addEventListener("abort", dropped, { once: true });
+  const source = reply.body[Symbol.asyncIterator]();
+  const body = (async function* () {
+    try {
+      for (; ; ) {
+        stall.arm();
+        const next = await until(source.next(), stall.signal);
+        stall.rest();
+        if (next.done) {
+          finished = true;
+          return;
+        }
+        if (!(next.value instanceof Uint8Array)) throw failed("a body chunk is not bytes");
+        if (next.value.byteLength > 0) yield next.value;
+      }
+    } finally {
+      await cancel();
+    }
+  })();
+  return {
+    ...reply.url !== void 0 ? { url: reply.url } : {},
+    status: reply.status,
+    statusText: reply.statusText,
+    headers: reply.headers,
+    body,
+    cancel
+  };
+}
+function sealedFetcher(hook, stop, idleMs = BODY_IDLE_MS) {
+  return async (request, stamp) => {
+    const stall = new Stall([request.signal, stop], idleMs);
+    const { signal } = stall;
+    if (signal.aborted) throw failed(signal.reason);
+    stall.arm();
+    const asked = Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return hook(sealedRequest(request, stamp, stall), { signal });
+    });
+    let reply;
+    try {
+      reply = await until(asked, signal);
+    } catch (e) {
+      void asked.then(dropSealedReply, () => void 0);
+      throw failed(e);
+    } finally {
+      stall.rest();
+    }
+    if (sealedReplyValid(reply)) return guarded(reply, stall);
+    dropSealedReply(reply);
+    throw failed("the reply is not a scrubbed response");
+  };
+}
+
 // src/kernel/test-hooks.ts
 var SYSCALL_HOOK = /* @__PURE__ */ Symbol.for("slicc-kernel.test.syscall");
 function setTestSyscallHook(hook) {
@@ -174,6 +391,280 @@ function setTestSyscallHook(hook) {
   else delete holder[SYSCALL_HOOK];
 }
 
+// src/bytes.ts
+function fresh(bytes, start = 0, end = bytes.length) {
+  return new Uint8Array(bytes.subarray(start, end));
+}
+
+// src/sealed-relay.ts
+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 askFetch(port, req, signal) {
+  signal.throwIfAborted();
+  const { bodyStream, ...wire } = req;
+  const { port1: near, port2: far } = new MessageChannel();
+  const upload = bodyStream?.[Symbol.asyncIterator]();
+  const head = Promise.withResolvers();
+  let reading;
+  let ended = false;
+  const end = (failure2) => {
+    if (ended) return;
+    ended = true;
+    signal.removeEventListener("abort", abort);
+    near.close();
+    void upload?.return?.().catch(() => void 0);
+    head.reject(failure2);
+    reading?.reject(failure2);
+    reading = void 0;
+  };
+  const abort = () => {
+    near.postMessage({ t: "cancel", reason: String(signal.reason) });
+    end(new Error(String(signal.reason)));
+  };
+  const pull = async () => {
+    try {
+      const next = await upload.next();
+      if (ended) return;
+      if (next.done) near.postMessage({ t: "end" });
+      else sendBytes(near, next.value);
+    } catch (err) {
+      if (!ended) near.postMessage({ t: "error", message: textOf(err) });
+    }
+  };
+  const respond = (message) => {
+    const { status, statusText, headers, url } = message;
+    const body = {
+      [Symbol.asyncIterator]: () => ({
+        next: () => {
+          if (ended) return Promise.resolve({ value: void 0, done: true });
+          reading = Promise.withResolvers();
+          near.postMessage({ t: "read" });
+          return reading.promise;
+        },
+        return: async () => {
+          await cancel();
+          return { value: void 0, done: true };
+        }
+      })
+    };
+    const cancel = async () => {
+      if (ended) return;
+      near.postMessage({ t: "cancel", reason: "cancelled" });
+      end(new Error("the request was cancelled"));
+    };
+    head.resolve({
+      ...url !== void 0 ? { url } : {},
+      status,
+      statusText,
+      headers,
+      body,
+      cancel
+    });
+  };
+  near.addEventListener("message", ({ data }) => {
+    if (data.t === "pull") void pull();
+    else if (data.t === "stop") void upload?.return?.().catch(() => void 0);
+    else if (data.t === "head") respond(data);
+    else if (data.t === "chunk") {
+      reading?.resolve({ value: data.bytes, done: false });
+      reading = void 0;
+    } else if (data.t === "end") {
+      reading?.resolve({ value: void 0, done: true });
+      reading = void 0;
+      end(new Error("the response ended"));
+    } else end(new Error(data.message));
+  });
+  near.addEventListener("close", () => end(new Error("the sealed fetch relay closed")));
+  near.start();
+  signal.addEventListener("abort", abort, { once: true });
+  const ask = {
+    req: { ...wire, ...upload ? { streamed: true } : {} },
+    port: far
+  };
+  port.postMessage({ sealedFetch: ask }, [far]);
+  return head.promise;
+}
+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 sealedAsker(port) {
+  const asks = /* @__PURE__ */ new Map();
+  let next = 0;
+  const hook = (req, { signal }) => {
+    const id = ++next;
+    const waiting = Promise.withResolvers();
+    asks.set(id, waiting);
+    const abort = () => {
+      if (!asks.delete(id)) return;
+      port.postMessage({ sealedAbort: { id, reason: signal.reason } });
+      waiting.reject(new Error(String(signal.reason)));
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    port.postMessage({ sealedAsk: { id, req } });
+    return waiting.promise.finally(() => signal.removeEventListener("abort", abort));
+  };
+  const answer = ({ id, reply, error }) => {
+    const waiting = asks.get(id);
+    if (!waiting) return;
+    asks.delete(id);
+    if (reply) waiting.resolve(reply);
+    else waiting.reject(new Error(error ?? "no reply"));
+  };
+  return { hook, fetch: (req, { signal }) => askFetch(port, req, signal), answer };
+}
+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);
+    try {
+      if (!hook) throw new Error("no vault is connected");
+      const reply = await hook(req, { signal: control.signal });
+      port.postMessage({ sealedReply: { id, reply } });
+    } catch (err) {
+      const error = err instanceof Error ? err.message : String(err);
+      port.postMessage({ sealedReply: { id, error } });
+    } finally {
+      asked.delete(id);
+    }
+  };
+  const abort = ({ id, reason }) => {
+    asked.get(id)?.abort(reason);
+    asked.delete(id);
+  };
+  return {
+    handle(data) {
+      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/testing.ts
 var failure = (code, message) => Object.assign(new Error(message), { code });
 var Stream = class {
@@ -336,6 +827,10 @@ function fakeUplink(options = {}) {
 export {
   fakeCronClock,
   fakeUplink,
+  placeholderFloor,
+  sealedAnswerer,
+  sealedAsker,
+  sealedFetcher,
   setTestSyscallHook
 };
 //# sourceMappingURL=testing.js.map