@ai-ecoverse/slicc-kernel 1.152.2 → 1.153.0

package/dist/node-driver-worker.js

@@ -46,6 +46,111 @@ function serveCdpPort(port, hook, request, onDone) {
   };
 }
 
+// src/embedder-relay.ts
+function fresh(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : bytes.slice();
+}
+function errorOf(err) {
+  const name = err?.name;
+  const message = err instanceof Error ? err.message : String(err);
+  return { name: typeof name === "string" ? name : "Error", message };
+}
+function bytesOf(reply) {
+  if (reply instanceof ReadableStream) return reply;
+  const bytes = typeof reply === "string" ? new TextEncoder().encode(reply) : reply instanceof Uint8Array ? reply : new Uint8Array(0);
+  return new ReadableStream({
+    start(controller) {
+      if (bytes.length > 0) controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+function bodyStream(id, state, post) {
+  return new ReadableStream(
+    {
+      pull: async (controller) => {
+        if (state.body.length === 0) post({ id, bodyPull: true });
+        while (state.body.length === 0 && !state.abort.signal.aborted) {
+          await new Promise((resolve) => {
+            state.wakeBody = resolve;
+          });
+        }
+        const next = state.body.shift();
+        if (next) controller.enqueue(next);
+        else controller.close();
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
+function embedderAnswerer(port, hookFor) {
+  const running = /* @__PURE__ */ new Map();
+  const post = (message, transfer = []) => port.postMessage({ embedderReply: message }, transfer);
+  const fail = (id, err) => {
+    running.delete(id);
+    post({ id, error: errorOf(err) });
+  };
+  const start = async (ask) => {
+    const state = { abort: new AbortController(), body: [], wakeBody: void 0 };
+    running.set(ask.id, state);
+    try {
+      const hook = hookFor(ask.client);
+      if (!hook || !Object.hasOwn(hook.kinds, ask.kind))
+        throw Object.assign(new Error(`this page does not answer ${ask.kind}`), {
+          name: "NotSupportedError"
+        });
+      const reply = await hook.handle({
+        kind: ask.kind,
+        options: ask.options,
+        body: bodyStream(ask.id, state, post),
+        stamp: ask.stamp,
+        signal: state.abort.signal,
+        progress: (line) => post({ id: ask.id, progress: String(line) })
+      });
+      state.reader = bytesOf(reply).getReader();
+      post({ id: ask.id, ready: true });
+    } catch (err) {
+      fail(ask.id, err);
+    }
+  };
+  const pull = async (id, state) => {
+    try {
+      const got = await state.reader.read();
+      if (got.done) {
+        running.delete(id);
+        post({ id, done: true });
+        return;
+      }
+      const bytes = fresh(got.value);
+      post({ id, chunk: bytes }, [bytes.buffer]);
+    } catch (err) {
+      fail(id, err);
+    }
+  };
+  const step = (message) => {
+    const state = running.get(message.id);
+    if (!state) return;
+    if ("body" in message) state.body.push(message.body);
+    else if ("bodyEnd" in message) state.body.push(null);
+    else if ("pull" in message) void pull(message.id, state);
+    else {
+      running.delete(message.id);
+      state.abort.abort(new DOMException(message.cancel, "AbortError"));
+      void state.reader?.cancel(message.cancel).catch(() => void 0);
+    }
+    state.wakeBody?.();
+  };
+  return {
+    handle(data) {
+      const message = data?.embedder;
+      if (!message) return false;
+      if ("ask" in message) void start(message.ask);
+      else step(message);
+      return true;
+    }
+  };
+}
+
 // src/facade/port.ts
 function serveFacadePort(port, hook, { name, stamp }, onDone) {
   let conn;
@@ -96,6 +201,27 @@ function serveFacadePort(port, hook, { name, stamp }, onDone) {
   };
 }
 
+// src/kernel/pipe.ts
+var PIPE_CAPACITY = 64 * 1024;
+
+// src/kernel/embedder.ts
+var EMBEDDER_HEADER_MAX = 64 * 1024;
+var EMBEDDER_WINDOW = 1024 * 1024;
+var EMBEDDER_BUDGET = 256 * 1024 * 1024;
+function kindsOf(hook) {
+  if (typeof hook?.handle !== "function" || typeof hook.kinds !== "object" || !hook.kinds)
+    throw new TypeError("requests needs kinds and handle");
+  return Object.fromEntries(
+    Object.entries(hook.kinds).map(([kind, policy]) => [
+      kind,
+      {
+        ...policy?.group !== void 0 ? { group: String(policy.group) } : {},
+        ...policy?.users ? { users: [...policy.users] } : {}
+      }
+    ])
+  );
+}
+
 // src/kernel/net/ws-queue.ts
 var INBOUND_LIMIT = 16 * 1024 * 1024;
 var MESSAGE_LIMIT = 64 * 1024 * 1024;
@@ -424,7 +550,7 @@ var KERNEL_SIGINFO = Object.freeze({
 });
 
 // src/bytes.ts
-function fresh(bytes, start = 0, end = bytes.length) {
+function fresh2(bytes, start = 0, end = bytes.length) {
   return new Uint8Array(bytes.subarray(start, end));
 }
 
@@ -481,7 +607,7 @@ function dialStream(port, onClose) {
   const writable = new WritableStream({
     write(chunk) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
-      const copy = fresh(chunk);
+      const copy = fresh2(chunk);
       const acked = new Promise((resolve, reject) => acks.push({ resolve, reject }));
       port.postMessage(copy, [copy.buffer]);
       return acked;
@@ -668,7 +794,7 @@ async function loopbackFetch(dial, input, options) {
 }
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 12];
+var PROTOCOL = [1, 13];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -696,7 +822,7 @@ var KernelCallError = class extends Error {
   }
 };
 var encoder2 = new TextEncoder();
-var bytesOf = (data) => typeof data === "string" ? encoder2.encode(data) : data;
+var bytesOf2 = (data) => typeof data === "string" ? encoder2.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -780,7 +906,9 @@ var Channel = class {
   call(call) {
     return this.request(call).done;
   }
+  requests;
   receive(data) {
+    if (this.requests?.handle(data)) return;
     if (data.traits && data.id === void 0) {
       if (this.remote) this.remote.traits = data.traits;
       for (const listener of [...this.traitsListeners]) listener(data.traits);
@@ -903,7 +1031,7 @@ async function spawnOn(channel, argv, opts) {
   });
   const started = Promise.withResolvers();
   let endedBy;
-  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf(stdin) } : {} };
+  const options = { ...rest, ...stdin !== void 0 ? { stdin: bytesOf2(stdin) } : {} };
   const { done } = channel.request(
     { op: "spawn", argv, options },
     {
@@ -986,7 +1114,7 @@ async function terminalOn(channel, argv, opts) {
       listener = next;
       if (next) for (const bytes of backlog.splice(0)) next(bytes);
     },
-    write: (data) => send({ action: "write", bytes: bytesOf(data) }),
+    write: (data) => send({ action: "write", bytes: bytesOf2(data) }),
     resize: (cols, rows) => send({ action: "resize", cols, rows }),
     signal: (name) => send({ action: "signal", signal: name }),
     close: () => send({ action: "close" })
@@ -1048,8 +1176,10 @@ function since(channel, minor, what, run) {
   }
   return run();
 }
-async function greet(channel, lock, timeoutMs) {
-  channel.post({ hello: { protocol: PROTOCOL, ...lock ? { lock } : {} } });
+async function greet(channel, lock, timeoutMs, requests) {
+  channel.post({
+    hello: { protocol: PROTOCOL, ...lock ? { lock } : {}, ...requests ? { requests } : {} }
+  });
   const timer = setTimeout(
     () => channel.end(
       new KernelGoneError(`no slicc-kernel answered on this port within ${timeoutMs} ms`)
@@ -1074,7 +1204,14 @@ async function attachKernel(port, options = {}) {
   const locks = options.locks === null ? void 0 : options.locks ?? locksOf();
   const own = await holdLock(locks);
   const channel = new Channel(port, own.release);
-  const hello = await greet(channel, own.name, options.timeoutMs ?? 1e4);
+  const requests = options.requests;
+  if (requests) channel.requests = embedderAnswerer(port, () => requests);
+  const hello = await greet(
+    channel,
+    own.name,
+    options.timeoutMs ?? 1e4,
+    requests ? kindsOf(requests) : void 0
+  );
   channel.protocol = hello.protocol;
   if (hello.lock && locks) void locks.request(hello.lock, () => channel.end(new KernelGoneError()));
   const transport = new RemoteTransport(
@@ -1237,7 +1374,7 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
       (result) => {
         if (result instanceof Uint8Array) {
           const whole = result.byteOffset === 0 && result.byteLength === result.buffer.byteLength;
-          const bytes = options.owned && whole ? result : fresh(result);
+          const bytes = options.owned && whole ? result : fresh2(result);
           reply({ id: data.id, result: bytes }, [bytes.buffer]);
         } else reply({ id: data.id, result: result ?? null });
       },