@ai-ecoverse/slicc-kernel 1.25.0 → 1.26.1

package/dist/node.js

@@ -2454,6 +2454,7 @@ Sec-WebSocket-Accept: ${accept2}\r
 // src/cdp/facade.ts
 var MAX_HEAD = 64 * 1024;
 var LIST_TIMEOUT = 1e4;
+var CLOSE_WAIT_MS = 1e3;
 function respond(status, body, type = "text/plain; charset=utf-8") {
   const bytes = new TextEncoder().encode(body);
   const head = latin1Bytes(
@@ -2599,7 +2600,11 @@ var CdpFacade = class {
   async upgrade(conn, incoming, req, runtime) {
     const accept2 = await acceptKey(req.headers);
     const host = await this.host(runtime);
-    await new Relay(conn, incoming, host, this.options.maxMessage ?? MAX_MESSAGE, this.stop.signal).start(switchingHead(accept2)).finally(() => host.close());
+    const limits = {
+      max: this.options.maxMessage ?? MAX_MESSAGE,
+      closeWaitMs: this.options.closeWaitMs ?? CLOSE_WAIT_MS
+    };
+    await new Relay(conn, incoming, host, limits, this.stop.signal).start(switchingHead(accept2)).finally(() => host.close());
   }
 };
 var Relay = class {
@@ -2609,12 +2614,14 @@ var Relay = class {
   incoming;
   host;
   max;
+  closeWaitMs;
   stop;
-  constructor(conn, incoming, host, max, stop) {
+  constructor(conn, incoming, host, limits, stop) {
     this.conn = conn;
     this.incoming = incoming;
     this.host = host;
-    this.max = max;
+    this.max = limits.max;
+    this.closeWaitMs = limits.closeWaitMs;
     this.stop = stop;
   }
   send(bytes) {
@@ -2640,8 +2647,15 @@ var Relay = class {
         void this.end(CLOSE.tooBig, `a message is over ${this.max} bytes`);
       else void this.send(frame(OP_TEXT, bytes));
     };
-    await Promise.race([this.pump(), hostGone]);
+    const pumping = this.pump();
+    await Promise.race([pumping, hostGone]);
     await this.writes;
+    let timer;
+    const waited = new Promise((resolve) => {
+      timer = setTimeout(resolve, this.closeWaitMs);
+    });
+    await Promise.race([pumping, waited]);
+    clearTimeout(timer);
   }
   async pump() {
     const reader = new WsReader(this.incoming, this.max);
@@ -3441,7 +3455,8 @@ function statOf(attr, path, mount) {
     dev: mount.dev,
     ...readonly(mount) ? { readonly: true } : {},
     ...mount.maxFile > 0 ? { maxFile: mount.maxFile } : {},
-    ...mount.caps.ranges ? { ranged: true } : {}
+    ...mount.caps.ranges ? { ranged: true } : {},
+    ...attr.etag !== void 0 ? { version: attr.etag } : {}
   };
 }
 function concat3(chunks2, total) {
@@ -3776,7 +3791,7 @@ var MountFs = class {
       this.table.forget(mount, real);
     }
   }
-  async pread(path, offset, length2) {
+  async pread(path, offset, length2, version) {
     const real = await this.follow(path);
     const found = this.at(real);
     if (!found && this.base.pread) return this.base.pread(real, offset, length2);
@@ -3785,7 +3800,15 @@ var MountFs = class {
     if ((await this.table.getattr(mount, real, rel2)).kind === "directory") {
       throw errnoError("EISDIR", real);
     }
-    const fh = await this.open(mount, rel2, false);
+    const fh = await mount.conn.call({
+      op: "open",
+      path: rel2,
+      write: false,
+      create: false,
+      truncate: false,
+      exclusive: false,
+      ...version !== void 0 ? { ifMatch: version } : {}
+    });
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     const chunks2 = [];
     let total = 0;
@@ -4047,7 +4070,8 @@ function statJson(s) {
     ...s.dev !== void 0 ? { dev: s.dev } : {},
     ...s.readonly ? { readonly: true } : {},
     ...s.maxFile ? { maxFile: s.maxFile } : {},
-    ...s.ranged ? { ranged: true } : {}
+    ...s.ranged ? { ranged: true } : {},
+    ...s.version !== void 0 ? { version: s.version } : {}
   };
 }
 async function readdirStat(fs, dir) {
@@ -4125,7 +4149,11 @@ async function ranged(fs, path, req) {
   if (!ops) throw syncError("ENOSYS", path);
   const offset = req.offset ?? 0;
   if (req.op === "pread")
-    return { ok: true, kind: "bytes", bytes: await ops.pread(path, offset, req.length ?? 0) };
+    return {
+      ok: true,
+      kind: "bytes",
+      bytes: await ops.pread(path, offset, req.length ?? 0, req.version)
+    };
   if (req.op === "pwrite") await ops.pwrite(path, offset, req.body ?? new Uint8Array(0), true);
   else await ops.truncate(path, req.length ?? 0);
   return done;
@@ -6401,17 +6429,21 @@ var AsyncRangedFile = class {
   pages;
   io;
   pinned = false;
+  version;
   path;
-  constructor(io, path, size) {
+  constructor(io, path, size, version) {
     this.io = io;
     this.path = path;
+    this.version = version;
     this.pages = new Pages(size);
   }
   size() {
     return this.pages.length;
   }
   async fetch(runs) {
-    for (const [start, n] of runs) this.pages.fill(start, await this.io.pread(this.path, start, n));
+    for (const [start, n] of runs) {
+      this.pages.fill(start, await this.io.pread(this.path, start, n, this.version));
+    }
   }
   async read(at, length2) {
     await this.fetch(this.pages.missing(at, length2));
@@ -6431,6 +6463,7 @@ var AsyncRangedFile = class {
     if (plan.shrink !== void 0) await this.io.truncate(this.path, plan.shrink);
     for (const run2 of plan.runs) await this.io.pwrite(this.path, run2.offset, run2.bytes, true);
     if (plan.extend !== void 0) await this.io.truncate(this.path, plan.extend);
+    this.version = void 0;
     this.pages.flushed();
   }
   async pin() {
@@ -6498,7 +6531,7 @@ var VfsNode = class {
     const io = rangedOps(this.fs);
     const st = io && !this.orphaned ? await this.fs.stat?.(this.path).catch(() => void 0) : void 0;
     if (io && st?.ranged) {
-      this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0);
+      this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0, st.version);
       return this.ranged;
     }
     await this.load();
@@ -7792,7 +7825,8 @@ async function dispatch(h, req) {
         write: req.write,
         create: req.create,
         truncate: req.truncate,
-        exclusive: req.exclusive
+        exclusive: req.exclusive,
+        ...req.ifMatch !== void 0 ? { ifMatch: req.ifMatch } : {}
       });
     case "read":
       return h.read(req.fh, req.offset, req.size);
@@ -8333,7 +8367,8 @@ function hostfsHandlers(current) {
   };
   const call = (op, body = {}) => current().call(op, body);
   async function writable(client, path, flags) {
-    const opening = () => client.call("open", { path: rel(path), ...flags });
+    const { ifMatch: _, ...asked } = flags;
+    const opening = () => client.call("open", { path: rel(path), ...asked });
     try {
       return { opened: await opening(), restore: void 0 };
     } catch (err) {
@@ -8349,7 +8384,7 @@ function hostfsHandlers(current) {
       return { opened: opened2, restore };
     }
   }
-  return {
+  const handlers = {
     getattr: async (path) => await call("stat", { path: rel(path) }),
     async readdir(path) {
       const { entries } = await call(
@@ -8362,6 +8397,10 @@ function hostfsHandlers(current) {
       const client = current();
       const token = client.token;
       const { opened: opened2, restore } = await writable(client, path, flags);
+      if (flags.ifMatch !== void 0 && opened2.attr?.etag !== flags.ifMatch) {
+        await client.call("release", { fh: opened2.fh }, true);
+        throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
+      }
       handles.set(++nextFh, {
         client,
         token,
@@ -8403,9 +8442,44 @@ function hostfsHandlers(current) {
     rename: async (from, to) => void await call("rename", { from: rel(from), to: rel(to) }),
     symlink: async (target, path) => void await call("symlink", { target, path: rel(path) }),
     readlink: async (path) => (await call("readlink", { path: rel(path) })).target,
-    setattr: async (path, change) => void await call("setattr", { path: rel(path), ...change }),
+    async setattr(path, { size, ...change }) {
+      if (size !== void 0 && !current().capabilities.ranges) await resize(handlers, path, size);
+      else if (size !== void 0) change = { ...change, size };
+      if (Object.keys(change).length > 0) await call("setattr", { path: rel(path), ...change });
+    },
     statfs: () => call("statfs")
   };
+  return handlers;
+}
+var KEEP = { write: false, create: false, truncate: false, exclusive: false };
+async function resize(h, path, size) {
+  const was = (await h.getattr(path)).size;
+  if (size === was) return;
+  const kept = [];
+  if (size < was && size > 0) {
+    const fh2 = await h.open(path, KEEP);
+    try {
+      for (let at = 0; at < size; ) {
+        const bytes = await h.read(fh2, at, size - at);
+        if (bytes.length === 0) break;
+        kept.push(bytes);
+        at += bytes.length;
+      }
+    } finally {
+      await h.release(fh2);
+    }
+  }
+  const fh = await h.open(path, { ...KEEP, write: true, truncate: size < was });
+  try {
+    if (size > was) await h.write(fh, size - 1, new Uint8Array(1));
+    let at = 0;
+    for (const bytes of kept) {
+      await h.write(fh, at, bytes);
+      at += bytes.length;
+    }
+  } finally {
+    await h.release(fh);
+  }
 }
 function sleep(ms, signal) {
   return new Promise((resolve) => {
@@ -8499,13 +8573,18 @@ async function openHostfs(spec, hook, fetch2, timing = {}) {
   const grant = () => hook(spec.source, { readonly: readonly2 });
   let active;
   const handlers = hostfsHandlers(() => active);
-  const served = serveFilesystem(port2, slot.handlers, {
-    symlinks: true,
-    chmod: true,
-    listingStats: true,
-    maxIo: HOSTFS_IO,
-    ...readonly2 ? { readonly: true } : {}
-  });
+  const ranged2 = () => active?.capabilities.ranges === true ? { ranges: true } : {};
+  const served = serveFilesystem(
+    port2,
+    { ...slot.handlers, mount: ranged2 },
+    {
+      symlinks: true,
+      chmod: true,
+      listingStats: true,
+      maxIo: HOSTFS_IO,
+      ...readonly2 ? { readonly: true } : {}
+    }
+  );
   const watching = keepWatching(
     {
       connect: async () => new HostfsClient(await grant(), grant, fetch2),