@ai-ecoverse/slicc-kernel 1.89.0 → 1.90.0

package/dist/index.js

@@ -326,6 +326,56 @@ function clipboardAnswerer(port, hook) {
   };
 }
 
+// src/facade/port.ts
+function serveFacadePort(port, hook, { name, stamp }, onDone) {
+  let conn;
+  let done = false;
+  const end = () => {
+    done = true;
+    port.close();
+    onDone?.();
+  };
+  const finish = () => {
+    if (done) return;
+    port.postMessage({ close: true });
+    end();
+  };
+  port.addEventListener(
+    "message",
+    ({ data }) => {
+      if (data.b !== void 0) conn?.send(data.b);
+      else if (data.close && !done) {
+        end();
+        conn?.close(typeof data.close === "string" ? data.close : void 0);
+      }
+    }
+  );
+  port.start?.();
+  new Promise((resolve) => resolve(hook(stamp, { name }))).then(
+    (opened) => {
+      conn = opened;
+      if (done) return opened.close();
+      opened.onmessage = (bytes) => {
+        if (done) return;
+        const copy = bytes.slice();
+        port.postMessage({ b: copy }, [copy.buffer]);
+      };
+      opened.onclose = () => finish();
+      port.postMessage({ open: true });
+    },
+    (e) => {
+      if (done) return;
+      port.postMessage({ error: e instanceof Error ? e.message : String(e) });
+      end();
+    }
+  );
+  return () => {
+    if (done) return;
+    conn?.close();
+    finish();
+  };
+}
+
 // src/fs/types.ts
 var DEFAULT_USERS = "enforce";
 
@@ -1286,7 +1336,7 @@ var RemoteTransport = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 10];
+var PROTOCOL = [1, 11];
 function locksOf(scope = globalThis) {
   const locks = scope.navigator?.locks;
   return typeof locks?.request === "function" ? locks : void 0;
@@ -1353,6 +1403,8 @@ var Channel = class {
   watching = /* @__PURE__ */ new Map();
   cdpHooks = /* @__PURE__ */ new Map();
   cdpOpen = /* @__PURE__ */ new Set();
+  facadeHooks = /* @__PURE__ */ new Map();
+  facadeOpen = /* @__PURE__ */ new Set();
   protocol = PROTOCOL;
   nextId = 0;
   port;
@@ -1375,6 +1427,8 @@ var Channel = class {
     this.remote?.fail(error);
     for (const close of [...this.cdpOpen]) close();
     this.cdpOpen.clear();
+    for (const close of [...this.facadeOpen]) close();
+    this.facadeOpen.clear();
     for (const call of this.pending.values()) call.reject(error);
     this.pending.clear();
     this.release();
@@ -1404,6 +1458,10 @@ var Channel = class {
       this.openCdp(data);
       return;
     }
+    if (data.facadeOpen && data.port) {
+      this.openFacade(data);
+      return;
+    }
     if (data.watch !== void 0) {
       this.watching.get(data.watch)?.(data.change);
       return;
@@ -1446,7 +1504,36 @@ var Channel = class {
     const close = serveCdpPort(port, hook, request, () => this.cdpOpen.delete(close));
     this.cdpOpen.add(close);
   }
+  openFacade({ facadeOpen: { registration, ...request }, port }) {
+    const hook = registration === void 0 ? void 0 : this.facadeHooks.get(registration);
+    if (!hook || this.failure) {
+      port.postMessage({ error: "this client no longer serves the facade" });
+      port.close();
+      return;
+    }
+    const close = serveFacadePort(port, hook, request, () => this.facadeOpen.delete(close));
+    this.facadeOpen.add(close);
+  }
 };
+async function serveFacadeOn(channel, name, hook) {
+  if (typeof hook !== "function") throw new TypeError("serveFacade: hook must be a function");
+  await since(channel, 11, "facade serving", async () => {
+  });
+  const { id, done } = channel.request({ op: "serve-facade", name });
+  channel.facadeHooks.set(id, hook);
+  try {
+    await done;
+  } catch (error) {
+    channel.facadeHooks.delete(id);
+    throw error;
+  }
+  return {
+    close: () => {
+      if (!channel.facadeHooks.delete(id)) return;
+      void channel.call({ op: "unserve-facade", registration: id }).catch(() => void 0);
+    }
+  };
+}
 async function serveCdpOn(channel, hook, options) {
   await since(channel, 5, "CDP serving", async () => {
   });
@@ -1680,6 +1767,7 @@ async function attachKernel(port, options = {}) {
     loopbackFetch: (input, options2) => loopbackFetch((o) => dialOn(channel, o), input, options2),
     fs: fsOn(channel),
     serveCdp: (hook, options2 = {}) => serveCdpOn(channel, hook, options2),
+    serveFacade: (name, hook) => serveFacadeOn(channel, name, hook),
     onTraits(listener) {
       channel.traitsListeners.add(listener);
       return () => channel.traitsListeners.delete(listener);
@@ -2019,6 +2107,7 @@ function initCall(options, transport) {
     ...uplinkInit(options.network?.uplink),
     ...options.hostfs ? { hostfs: true } : {},
     ...options.cdp ? { cdp: true } : {},
+    ...facadesInit(options.facades),
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
     users: options.users === void 0 ? DEFAULT_USERS : options.users,
     ...options.onDenial ? { denials: true } : {},
@@ -2031,6 +2120,46 @@ function initCall(options, transport) {
     } : {}
   };
 }
+function hostedMessage(data, on) {
+  if ("cdpOpen" in data) on.cdp.open(data);
+  else if ("facadeOpen" in data) on.facades.open(data);
+  else if ("mountPolicy" in data) void on.policy(data.mountPolicy);
+  else if ("medium" in data) on.medium(data.medium);
+  else if ("hostfs" in data) void on.hostfs(data.hostfs);
+  else return false;
+  return true;
+}
+function facadesInit(specs) {
+  if (!specs) return {};
+  const facades = {};
+  for (const [name, spec] of Object.entries(specs)) {
+    if (spec?.hook !== void 0 && typeof spec.hook !== "function") {
+      throw new TypeError(`facades.${name}: hook must be a function`);
+    }
+    facades[name] = { port: spec?.port, ...spec?.hook ? { hook: true } : {} };
+  }
+  return { facades };
+}
+function facadeBridge(specs) {
+  const open = /* @__PURE__ */ new Set();
+  let closed = false;
+  return {
+    open({ facadeOpen, port }) {
+      const hook = specs?.[facadeOpen.name]?.hook;
+      if (!hook || closed) {
+        port.postMessage({ error: "no facade host" });
+        port.close();
+        return;
+      }
+      const close = serveFacadePort(port, hook, facadeOpen, () => open.delete(close));
+      open.add(close);
+    },
+    close() {
+      closed = true;
+      for (const close of [...open]) close();
+    }
+  };
+}
 function cdpBridge(hook) {
   const open = /* @__PURE__ */ new Set();
   let closed = false;
@@ -2141,6 +2270,7 @@ function checkOptions(options) {
   }
   if (options.protect) protectInit(options.protect);
   integrityOptions(options.protect?.integrity);
+  facadesInit(options.facades);
 }
 function hookRelays(worker, options) {
   const sealed = sealedAnswerer(worker, options.sealed);
@@ -2187,11 +2317,13 @@ async function createKernel(options = {}) {
     (req) => call(req)
   );
   const cdp = cdpBridge(options.cdp);
+  const facades = facadeBridge(options.facades);
   const sealed = hookRelays(worker, options);
   const approvals = approver(options.approve, worker);
   const fail = (error) => {
     dials.reset();
     cdp.close();
+    facades.close();
     sealed.close();
     approvals.close();
     failure3 = error;
@@ -2233,15 +2365,13 @@ async function createKernel(options = {}) {
     options.onDenial?.(data.denial);
     return true;
   };
+  const hosts = { cdp, facades, policy, medium: pendingMedium, hostfs: grantHostfs };
   worker.addEventListener("message", ({ data }) => {
     if (aside(data)) return;
     if (approvals.handle(data)) return;
     if ("net" in data) return bridge?.answer(data);
     if ("uplink" in data) return uplinks?.answer(data);
-    if ("cdpOpen" in data) return cdp.open(data);
-    if ("mountPolicy" in data) return void policy(data.mountPolicy);
-    if ("medium" in data) return pendingMedium(data.medium);
-    if ("hostfs" in data) return void grantHostfs(data.hostfs);
+    if (hostedMessage(data, hosts)) return;
     const call2 = pending.get(data.id);
     if (!call2) return;
     if (data.fd !== void 0) return call2.output?.(data.fd, data.bytes);