@ai-ecoverse/slicc-kernel 1.53.4 → 1.54.0

package/dist/node.js

@@ -11156,7 +11156,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 +11361,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 +12599,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
       );
     }
@@ -13876,6 +14060,7 @@ export {
   createNodeKernel,
   fetchTransport,
   memoryRoot,
-  nodeTransport
+  nodeTransport,
+  serveHostfsPort
 };
 //# sourceMappingURL=node.js.map