@ai-ecoverse/slicc-kernel 1.88.0 → 1.88.1

package/dist/node-process-worker.js

@@ -3850,7 +3850,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.88.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.88.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });

package/dist/node.js

@@ -6585,12 +6585,12 @@ async function interruptible(work, signal) {
   if (signal.aborted) throw new KernelError("EINTR");
   let stop = () => {
   };
-  const interrupted2 = new Promise((_, reject) => {
+  const interrupted3 = new Promise((_, reject) => {
     stop = () => reject(new KernelError("EINTR"));
     signal.addEventListener("abort", stop, { once: true });
   });
   try {
-    return await Promise.race([work, interrupted2]);
+    return await Promise.race([work, interrupted3]);
   } finally {
     signal.removeEventListener("abort", stop);
   }
@@ -7890,11 +7890,12 @@ var MountFs = class {
     });
   }
   async chmod(path, mode) {
-    const found = this.at(path);
-    if (!found) return this.base.chmod(path, mode);
-    this.writable(found.mount, normalizePath(path));
+    const real = await this.follow(path);
+    const found = this.at(real);
+    if (!found) return this.base.chmod(real, mode);
+    this.writable(found.mount, real);
     if (!found.mount.caps.chmod) return;
-    this.table.forget(found.mount, normalizePath(path));
+    this.table.forget(found.mount, real);
     await found.mount.conn.call({ op: "setattr", path: found.rel, mode });
   }
   async utimes(path, atime, mtime) {
@@ -8938,7 +8939,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.88.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.88.1" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -11826,16 +11827,16 @@ function interruption(signal) {
 }
 async function selectFds(fds, read, write, timeoutMs, interrupt) {
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-  const interrupted2 = interruption(interrupt);
-  interrupted2.promise.catch(() => {
+  const interrupted3 = interruption(interrupt);
+  interrupted3.promise.catch(() => {
   });
   try {
-    return await waitReady(fds, read, write, deadline, interrupted2.promise);
+    return await waitReady(fds, read, write, deadline, interrupted3.promise);
   } finally {
-    interrupted2.done();
+    interrupted3.done();
   }
 }
-async function waitReady(fds, read, write, deadline, interrupted2) {
+async function waitReady(fds, read, write, deadline, interrupted3) {
   for (; ; ) {
     const now = ready(fds, read, write);
     if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
@@ -11847,7 +11848,7 @@ async function waitReady(fds, read, write, deadline, interrupted2) {
     let timer;
     const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => timer = setTimeout(resolve2, deadline - Date.now()))];
     try {
-      await Promise.race([...changes, ...expiry, interrupted2]);
+      await Promise.race([...changes, ...expiry, interrupted3]);
     } finally {
       round.abort();
       clearTimeout(timer);
@@ -14776,63 +14777,137 @@ function compile(secrets, options = {}) {
 
 // src/kernel/scrub-file.ts
 var SCRUB_IDLE_MS = 50;
+var SCRUB_NONBLOCK_MAX = 64 * 1024;
 var encoder5 = new TextEncoder();
 function scrubberOf(secrets) {
   const usable = secrets.filter((s) => encoder5.encode(s.value).length >= MIN_VALUE);
   return usable.length > 0 ? compile(usable, { idleMs: SCRUB_IDLE_MS }) : void 0;
 }
-async function writeAll2(file, bytes, signal) {
+async function writeAll2(file, bytes) {
   const write = file.write;
-  for (let at = 0; at < bytes.length; ) {
-    at += await write.call(file, bytes.subarray(at), at === 0 ? signal : void 0);
-  }
+  for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
 function bound(file, key) {
   const method = file[key];
   return typeof method === "function" ? { [key]: method.bind(file) } : {};
 }
+function interrupted2(err) {
+  const code = err?.code;
+  return code === "EINTR" || code === "EAGAIN";
+}
 function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   const file = inner.file;
   const stream2 = scrubber.stream();
-  let queue = Promise.resolve();
+  let tail = Promise.resolve();
+  let pending = 0;
+  let busy = false;
   let timer;
   let failed3;
+  const waiters = /* @__PURE__ */ new Set();
+  const quiet2 = () => !busy && pending === 0;
+  const wake = () => {
+    for (const waiter of [...waiters]) waiter();
+  };
   const raise = () => {
     if (failed3 === void 0) return;
     const err = failed3;
     failed3 = void 0;
     throw err;
   };
-  const enqueue = (bytes, signal) => {
-    const next2 = queue.then(() => bytes.length > 0 ? writeAll2(file, bytes, signal) : void 0);
-    queue = next2.catch(() => void 0);
-    return next2;
+  const later = (bytes) => {
+    if (bytes.length === 0) return;
+    pending += 1;
+    tail = tail.then(() => writeAll2(file, bytes)).catch((err) => {
+      if (failed3 === void 0) failed3 = err;
+    }).finally(() => {
+      pending -= 1;
+      if (quiet2()) wake();
+    });
+  };
+  const settling = (signal) => new Promise((resolve2, reject) => {
+    const done4 = () => {
+      waiters.delete(done4);
+      signal?.removeEventListener("abort", stop);
+      resolve2();
+    };
+    const stop = () => {
+      waiters.delete(done4);
+      reject(new KernelError("EINTR"));
+    };
+    if (signal?.aborted) return stop();
+    waiters.add(done4);
+    signal?.addEventListener("abort", stop, { once: true });
+  });
+  const settled = async () => {
+    while (!quiet2()) await settling();
+  };
+  const changed = async (signal) => {
+    const round = new AbortController();
+    const stop = signal ? AbortSignal.any([signal, round.signal]) : round.signal;
+    try {
+      const own = settling(stop);
+      await Promise.race(file.changed ? [own, file.changed(stop)] : [own]);
+    } catch (err) {
+      throw signal?.aborted ? new KernelError("EINTR") : err;
+    } finally {
+      round.abort();
+    }
+  };
+  const turn = async (signal) => {
+    for (let waited = false; ; waited = true) {
+      if (quiet2() && (pollFile(file).writable || !file.changed)) {
+        busy = true;
+        return;
+      }
+      if (signal?.aborted) throw new KernelError(waited ? "EINTR" : "EAGAIN");
+      await changed(signal);
+    }
+  };
+  const send = async (out, signal) => {
+    const write = file.write;
+    for (let at = 0; at < out.length; ) {
+      try {
+        at += await write.call(file, out.subarray(at), signal);
+      } catch (err) {
+        if (!signal?.aborted || !interrupted2(err)) throw err;
+      }
+      if (at < out.length && signal?.aborted) return later(out.subarray(at));
+    }
   };
   const release = () => {
     timer = void 0;
-    enqueue(stream2.idle()).catch((err) => {
-      failed3 = err;
-    });
+    later(stream2.idle());
   };
   return new OpenFile({
     ...bound(file, "read"),
     ...bound(file, "peek"),
-    ...bound(file, "poll"),
-    ...bound(file, "changed"),
     ...bound(file, "stat"),
+    poll: () => {
+      const state = pollFile(file);
+      return quiet2() ? state : { ...state, writable: false };
+    },
+    changed,
     ...file.tty ? { tty: file.tty } : {},
     ...file.clipboard ? { clipboard: file.clipboard } : {},
     ...file.write ? {
       write: async (bytes, signal) => {
-        if (timer !== void 0) clearTimeout(timer);
-        raise();
-        await enqueue(stream2.push(bytes), signal);
+        await turn(signal);
+        const taken = signal?.aborted && bytes.length > SCRUB_NONBLOCK_MAX ? bytes.subarray(0, SCRUB_NONBLOCK_MAX) : bytes;
+        try {
+          raise();
+          if (timer !== void 0) clearTimeout(timer);
+          timer = void 0;
+          await send(stream2.push(taken), signal);
+        } finally {
+          busy = false;
+          if (quiet2()) wake();
+        }
         timer = setTimeout(release, idleMs);
-        return bytes.length;
+        return taken.length;
       }
     } : {},
     flush: async () => {
-      await queue;
+      await settled();
       raise();
       await file.flush?.();
     },
@@ -14840,7 +14915,9 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
       if (timer !== void 0) clearTimeout(timer);
       let failure;
       try {
-        await enqueue(stream2.end());
+        await settled();
+        later(stream2.end());
+        await settled();
         raise();
       } catch (err) {
         failure = { err };
@@ -15016,12 +15093,12 @@ var SealedChannel = class {
     if (signal.aborted) throw new KernelError("EINTR");
     let stop = () => {
     };
-    const interrupted2 = new Promise((_, reject) => {
+    const interrupted3 = new Promise((_, reject) => {
       stop = () => reject(new KernelError("EINTR"));
       signal.addEventListener("abort", stop, { once: true });
     });
     try {
-      await Promise.race([flight.done, interrupted2]);
+      await Promise.race([flight.done, interrupted3]);
     } finally {
       signal.removeEventListener("abort", stop);
     }
@@ -18087,11 +18164,9 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
-  treeScrubs(pid, req) {
+  treeScrubs(req) {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
-    const scrubs = req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
-    if (scrubs) this.scrubs.set(pid, scrubs);
-    return scrubs;
+    return req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
   }
   start(req) {
     this.sampling();
@@ -18099,7 +18174,7 @@ var Launcher = class {
       throw new SpawnError("ESRCH");
     }
     const pid = req.pid ?? this.nextPid++;
-    const scrubs = this.treeScrubs(pid, req);
+    const scrubs = this.treeScrubs(req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
     const decided = req.decided ?? Promise.resolve(true);
@@ -18169,6 +18244,7 @@ var Launcher = class {
       ...this.shownIds(req)
     });
     this.processes.set(pid, handle);
+    if (scrubs) this.scrubs.set(pid, scrubs);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
     if (req.tag !== void 0) this.tags.set(pid, req.tag);