@ai-ecoverse/slicc-kernel 1.53.4 → 1.54.1

package/dist/node.js

@@ -10461,6 +10461,9 @@ function fingerprint(headers) {
   const fields = MATCHED.map((name2) => header2(headers, name2) ?? "");
   return JSON.stringify([...fields, header2(headers, "authorization") !== void 0]);
 }
+function unauthorized(print) {
+  return JSON.stringify([...JSON.parse(print).slice(0, -1), false]);
+}
 function followedWith(status, method) {
   if (status === 303 && method !== "GET" && method !== "HEAD") return "GET";
   if ((status === 301 || status === 302) && method === "POST") return "GET";
@@ -10501,9 +10504,17 @@ function replayingHops(inner, heldMs = HELD_MS) {
     const [hop, ...rest2] = chain.hops;
     const location = hop && header2(hop.headers, "location");
     if (!hop || location === void 0) return chain.final;
-    const next2 = new URL(location, hop.url).href;
+    const target = new URL(location, hop.url);
+    target.hash = "";
     const method = followedWith(hop.status, chain.method);
-    hold(keyOf2(chain.owner, method, next2), { ...chain, method, hops: rest2 });
+    const away = target.origin !== new URL(hop.url).origin;
+    const print = away ? unauthorized(chain.fingerprint) : chain.fingerprint;
+    hold(keyOf2(chain.owner, method, target.href), {
+      ...chain,
+      method,
+      fingerprint: print,
+      hops: rest2
+    });
     return bodiless(hop);
   };
   return {
@@ -11156,7 +11167,7 @@ function hostfsHandlers(current) {
   const handles = /* @__PURE__ */ new Map();
   let nextFh = 0;
   const fresh = (remote) => {
-    if (remote.client.token === remote.token) return remote;
+    if (remote.client.token === remote.token && !remote.client.gone) return remote;
     throw fsError2("ESTALE", "the folder was granted again, so this open file is gone");
   };
   const live = (fh) => {
@@ -11361,10 +11372,190 @@ function keepWatching(loop, signal) {
 function invalidation(event) {
   return event.paths ?? true;
 }
-function grantConnect(hook, fetch2) {
+var PORT_REQUEST_MS = 6e4;
+var PORT_MS_PER_MIB = 1e3;
+var nextPortToken = 0;
+var PortTransport = class {
+  capabilities;
+  token;
+  port;
+  requestMs;
+  waiting = /* @__PURE__ */ new Map();
+  next = 0;
+  dead;
+  constructor(grant, requestMs = PORT_REQUEST_MS) {
+    this.port = grant.port;
+    this.requestMs = requestMs;
+    this.capabilities = grant.capabilities ?? {};
+    this.token = grant.token ?? `port-${++nextPortToken}`;
+    this.port.addEventListener("message", (event) => {
+      this.waiting.get(event.data?.id)?.(event.data);
+    });
+    this.port.addEventListener("close", () => this.fail("the folder's port closed"));
+    this.port.start();
+  }
+  get maxIo() {
+    return this.capabilities.maxIo ?? HOSTFS_IO;
+  }
+  get gone() {
+    return this.dead !== void 0;
+  }
+  fail(why) {
+    if (this.dead === void 0) this.port.close();
+    this.dead ??= why;
+    for (const settle of [...this.waiting.values()])
+      settle({ id: 0, error: { code: "ENOTCONN", message: why } });
+  }
+  ask(message3, bytes = 0, transfer = []) {
+    const id2 = ++this.next;
+    if (this.dead) return Promise.reject(fsError2("ENOTCONN", this.dead));
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(
+        () => {
+          this.waiting.delete(id2);
+          reject(fsError2("ETIMEDOUT", "the folder's port did not answer"));
+          this.fail("the folder's port stopped answering");
+        },
+        this.requestMs + Math.ceil(bytes / 1048576) * PORT_MS_PER_MIB
+      );
+      this.waiting.set(id2, (reply) => {
+        clearTimeout(timer);
+        this.waiting.delete(id2);
+        if (reply.error) reject(fsError2(reply.error.code ?? "EIO", reply.error.message ?? ""));
+        else resolve(reply);
+      });
+      try {
+        this.port.postMessage({ id: id2, ...message3 }, transfer);
+      } catch (err) {
+        this.fail(`the folder's port is closed: ${err.message}`);
+      }
+    });
+  }
+  async call(op, body = {}) {
+    return (await this.ask({ op: "call", name: op, body })).result;
+  }
+  async read(fh, offset, size, ifMatch) {
+    const reply = await this.ask(
+      { op: "read", fh, offset, size, ...ifMatch ? { ifMatch } : {} },
+      size
+    );
+    return reply.bytes ?? new Uint8Array(0);
+  }
+  async write(fh, offset, bytes) {
+    await this.ask({ op: "write", fh, offset, bytes }, bytes.length);
+  }
+  watch(signal, onEvent, onOpen = () => void 0) {
+    const id2 = ++this.next;
+    if (this.dead) return Promise.reject(fsError2("ENOTCONN", this.dead));
+    if (signal.aborted) {
+      this.fail("the folder's watch ended");
+      return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+      const finish = () => {
+        this.waiting.delete(id2);
+        signal.removeEventListener("abort", stop);
+      };
+      const stop = () => {
+        finish();
+        try {
+          this.port.postMessage({ id: id2, op: "unwatch" });
+        } catch {
+        }
+        resolve();
+      };
+      this.waiting.set(id2, (reply) => {
+        if (reply.open) return onOpen();
+        if (reply.event) return onEvent(reply.event);
+        finish();
+        if (reply.error) reject(fsError2(reply.error.code ?? "ENOTCONN", reply.error.message ?? ""));
+        else resolve();
+      });
+      signal.addEventListener("abort", stop, { once: true });
+      try {
+        this.port.postMessage({ id: id2, op: "watch" });
+      } catch (err) {
+        finish();
+        reject(fsError2("ENOTCONN", `the folder's port is closed: ${err.message}`));
+      }
+    }).finally(() => this.fail("the folder's watch ended"));
+  }
+};
+var errorOf = (err) => ({
+  code: typeof codeOf4(err) === "string" ? codeOf4(err) : "EIO",
+  message: err?.message ?? String(err)
+});
+function serveHostfsPort(port, transport) {
+  const watches = /* @__PURE__ */ new Map();
+  const send = (reply, transfer = []) => port.postMessage(reply, transfer);
+  const listener = async ({
+    data
+  }) => {
+    const { id: id2, op } = data;
+    if (op === "unwatch") return watches.get(id2)?.abort();
+    if (op === "watch") {
+      const stop2 = new AbortController();
+      watches.set(id2, stop2);
+      try {
+        await transport.watch(
+          stop2.signal,
+          (event) => send({ id: id2, event }),
+          () => send({ id: id2, open: true })
+        );
+        send({ id: id2, end: true });
+      } catch (err) {
+        send({ id: id2, error: errorOf(err) });
+      } finally {
+        watches.delete(id2);
+      }
+      return;
+    }
+    try {
+      if (op === "read") {
+        const read = await transport.read(
+          data.fh,
+          data.offset,
+          data.size,
+          data.ifMatch
+        );
+        const bytes = read.slice();
+        return send({ id: id2, bytes }, [bytes.buffer]);
+      }
+      if (op === "write") {
+        await transport.write(data.fh, data.offset, data.bytes);
+        return send({ id: id2 });
+      }
+      if (op !== "call") throw fsError2("EINVAL", `unknown hostfs port op ${op}`);
+      send({
+        id: id2,
+        result: await transport.call(data.name, data.body)
+      });
+    } catch (err) {
+      send({ id: id2, error: errorOf(err) });
+    }
+  };
+  const stop = () => {
+    port.removeEventListener("message", listener);
+    port.removeEventListener("close", stop);
+    for (const watch of watches.values()) watch.abort();
+    port.close();
+  };
+  port.addEventListener("message", listener);
+  port.addEventListener("close", stop);
+  port.start();
+  return stop;
+}
+function grantConnect(hook, fetch2, requestMs) {
   return async (source, options) => {
-    const grant = () => hook(source, options);
-    return new HostfsClient(await grant(), grant, fetch2);
+    const first = await hook(source, options);
+    if ("port" in first) return new PortTransport(first, requestMs);
+    const grant = async () => {
+      const again = await hook(source, options);
+      if ("port" in again)
+        throw fsError2("ESTALE", "the folder moved to a port, so its open files are gone");
+      return again;
+    };
+    return new HostfsClient(first, grant, fetch2);
   };
 }
 async function openHostfs(spec, connect, timing = {}) {
@@ -12419,7 +12610,11 @@ var Launcher = class {
         throw fsError("ENODEV", "this kernel has no hostfs hook (createKernel({ hostfs }))");
       return openHostfs(
         spec,
-        grantConnect(hostfs, hostfsFetch ?? ((url, init) => fetch(url, init))),
+        grantConnect(
+          hostfs,
+          hostfsFetch ?? ((url, init) => fetch(url, init)),
+          hostfsTiming?.requestMs
+        ),
         hostfsTiming
       );
     }
@@ -13693,6 +13888,7 @@ function nodeTransport() {
   return { ...transport, traits: { ...transport.traits, crossOrigin: "any" } };
 }
 var TERMINATED = "the kernel is terminated";
+var EXIT_GRACE_MS = 50;
 function nodeWorker(file, live, closed) {
   const errors = /* @__PURE__ */ new Set();
   const messages = /* @__PURE__ */ new Map();
@@ -13713,7 +13909,9 @@ function nodeWorker(file, live, closed) {
     live.add(kill);
     worker.once("exit", (code) => {
       live.delete(kill);
-      if (!ending) fail3(`the process worker exited with ${code}`);
+      setTimeout(() => {
+        if (!ending) fail3(`the process worker exited with ${code}`);
+      }, EXIT_GRACE_MS);
     });
     worker.on("error", (err) => fail3(String(err)));
   } else {
@@ -13876,6 +14074,7 @@ export {
   createNodeKernel,
   fetchTransport,
   memoryRoot,
-  nodeTransport
+  nodeTransport,
+  serveHostfsPort
 };
 //# sourceMappingURL=node.js.map