@ai-ecoverse/slicc-kernel 1.53.4 → 1.54.0

package/dist/kernel-worker.js

@@ -11401,7 +11401,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) => {
@@ -11606,10 +11606,126 @@ 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 settle3 of [...this.waiting.values()])
+      settle3({ 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"));
+  }
+};
+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 = {}) {
@@ -12655,7 +12771,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
       );
     }