@ai-ecoverse/slicc-kernel 1.66.0 → 1.67.0

package/dist/node.js

@@ -1,6 +1,11 @@
 // src/node.ts
 import { MessageChannel as MessageChannel2, Worker } from "node:worker_threads";
 
+// src/bytes.ts
+function fresh(bytes, start2 = 0, end = bytes.length) {
+  return new Uint8Array(bytes.subarray(start2, end));
+}
+
 // src/cdp/port.ts
 function serveCdpPort(port, hook, request, onDone) {
   let conn;
@@ -2034,7 +2039,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         }
         if (typeof data === "string") peer.postMessage({ net: "ws-message", nid, data });
         else {
-          const bytes = data.slice();
+          const bytes = fresh(data);
           peer.postMessage({ net: "ws-message", nid, data: bytes }, [bytes.buffer]);
         }
         flow.inflight += payloadSize(data);
@@ -2072,7 +2077,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         open.delete(nid);
         peer.postMessage({ net: "end", nid });
       } else {
-        const bytes = next2.value.slice();
+        const bytes = fresh(next2.value);
         peer.postMessage({ net: "chunk", nid, bytes }, [bytes.buffer]);
       }
     } catch (e) {
@@ -2366,7 +2371,7 @@ var UserDb = class {
       joined(name2, extra);
       group.push({ name: name2, gid: uid, members: [] });
       passwd.push(row);
-      const fresh = !await this.fs.exists(home);
+      const fresh2 = !await this.fs.exists(home);
       await this.fs.mkdir(home, { recursive: true });
       try {
         await this.provision(row);
@@ -2374,7 +2379,7 @@ var UserDb = class {
         await this.fs.mkdir("/etc", { recursive: true });
         await this.commit(formatPasswd(passwd), formatGroup(group));
       } catch (err) {
-        if (fresh) await this.fs.rm(home, { recursive: true, force: true });
+        if (fresh2) await this.fs.rm(home, { recursive: true, force: true });
         throw err;
       }
       remember();
@@ -2519,7 +2524,7 @@ async function fsCall(fs, method, args, owner, g) {
   }
   switch (method) {
     case "readFile": {
-      const bytes = (await fs.readFileBuffer(path(0))).slice();
+      const bytes = fresh(await fs.readFileBuffer(path(0)));
       return { result: bytes, transfer: [bytes.buffer] };
     }
     case "writeFile":
@@ -5530,11 +5535,11 @@ var ChildTable = class {
     return [...this.children.keys()];
   }
   captured(pid, slot2) {
-    const slots = this.leftovers.get(pid);
-    const chunks2 = slots?.get(slot2);
-    if (!slots || !chunks2) return new Uint8Array(0);
-    slots.delete(slot2);
-    if (slots.size === 0) this.leftovers.delete(pid);
+    const slots2 = this.leftovers.get(pid);
+    const chunks2 = slots2?.get(slot2);
+    if (!slots2 || !chunks2) return new Uint8Array(0);
+    slots2.delete(slot2);
+    if (slots2.size === 0) this.leftovers.delete(pid);
     return concat2(chunks2);
   }
 };
@@ -5721,9 +5726,9 @@ var HeldPaths = class extends Map {
     return this.keptHandles.get(handle);
   }
   keep(path, file) {
-    const fresh = this.handlesAt(path).filter((id2) => !this.keptHandles.has(id2));
-    for (const id2 of fresh) this.keptHandles.set(id2, file);
-    this.uses.set(file, Math.max(fresh.length, 1));
+    const fresh2 = this.handlesAt(path).filter((id2) => !this.keptHandles.has(id2));
+    for (const id2 of fresh2) this.keptHandles.set(id2, file);
+    this.uses.set(file, Math.max(fresh2.length, 1));
     this.unlinked.set(path, file);
   }
   unkeep(path, file) {
@@ -6279,7 +6284,7 @@ var MountFs = class {
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     try {
       for (let offset = 0; offset < bytes.length; offset += chunk2) {
-        const part = bytes.slice(offset, offset + chunk2);
+        const part = fresh(bytes, offset, offset + chunk2);
         await mount.conn.call({ op: "write", fh, offset, bytes: part }, [part.buffer]);
       }
     } finally {
@@ -6376,7 +6381,7 @@ var MountFs = class {
   async writeRuns(mount, fh, offset, bytes, transfer) {
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     for (let at = 0; at < bytes.length; at += chunk2) {
-      const part = handed(bytes, transfer, chunk2) ? bytes : bytes.slice(at, at + chunk2);
+      const part = handed(bytes, transfer, chunk2) ? bytes : fresh(bytes, at, at + chunk2);
       await mount.conn.call({ op: "write", fh, offset: offset + at, bytes: part }, [part.buffer]);
     }
   }
@@ -6608,8 +6613,8 @@ var MountFs = class {
     }
     this.writable(mount, real);
     const { uid, gid, mode } = change;
-    const fresh = change.kind === "new" && { uid, gid, mode };
-    const set2 = fresh ? await this.driverOwner(found, real, fresh, false) : change;
+    const fresh2 = change.kind === "new" && { uid, gid, mode };
+    const set2 = fresh2 ? await this.driverOwner(found, real, fresh2, false) : change;
     this.table.forget(mount, real);
     const attrs = Object.entries({ uid: set2.uid, gid: set2.gid, mode: set2.mode });
     await mount.conn.call({
@@ -7006,7 +7011,9 @@ async function dispatchOne(entry, req) {
 
 // src/realm/sync-sab-wire.ts
 var SAB_HEADER_I32 = 16;
-var SAB_HEADER_BYTES = SAB_HEADER_I32 * 4;
+var SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
+var SAB_CLOCK_I64 = 3;
+var SAB_HEADER_BYTES = SAB_CLOCK_OFFSET + SAB_CLOCK_I64 * 8;
 var SAB_I_STATE = 0;
 var SAB_I_SEQ = 1;
 var SAB_I_STATUS = 2;
@@ -7156,6 +7163,146 @@ function attachSyncSabResponder(port, sab, token, opts) {
   };
 }
 
+// src/kernel/cpu-clock.ts
+var IDLE_OPS = /* @__PURE__ */ new Set([
+  "fd-select",
+  "proc-wait",
+  "proc-exec",
+  "sig-pause",
+  "sock-accept",
+  "sock-connect"
+]);
+var SYS_CAP_US = 2e4;
+var LOCAL = SAB_CLOCK_OFFSET;
+var IDLE = 1;
+function epochMicros() {
+  return Math.floor((performance.timeOrigin + performance.now()) * 1e3);
+}
+function slots(sab) {
+  return new BigInt64Array(sab, LOCAL, SAB_CLOCK_I64);
+}
+var rawWait = Atomics.wait.bind(Atomics);
+function localIdle(sab, now) {
+  const state = Number(Atomics.load(slots(sab), IDLE));
+  if (state >= 0) return { idle: state, waiting: false };
+  return { idle: Math.max(0, now + state), waiting: true };
+}
+var CpuClock = class {
+  start;
+  sys = 0;
+  idle = 0;
+  since = 0;
+  kind = "sys";
+  stopped = false;
+  last = { utime: 0, stime: 0 };
+  sab;
+  now;
+  constructor(sab, now = epochMicros) {
+    this.sab = sab;
+    this.now = now;
+    this.start = now();
+  }
+  enter(op) {
+    this.since = this.now();
+    this.kind = this.stopped || IDLE_OPS.has(op) ? "idle" : "sys";
+  }
+  leave() {
+    if (this.since === 0) return;
+    this.add((this.frozen ?? this.now()) - this.since);
+    this.since = 0;
+  }
+  stop(stopped) {
+    if (stopped === this.stopped) return;
+    this.stopped = stopped;
+    if (this.since === 0 || !stopped || this.frozen !== void 0) return;
+    const now = this.now();
+    this.add(now - this.since);
+    this.since = now;
+    this.kind = "idle";
+  }
+  frozen;
+  freeze() {
+    this.frozen ??= this.now();
+  }
+  running() {
+    if (this.frozen !== void 0) return false;
+    const now = this.now();
+    const busy = this.since === 0 || this.kind === "sys" && now - this.since < SYS_CAP_US;
+    return busy && !localIdle(this.sab, now).waiting;
+  }
+  times() {
+    const now = this.frozen ?? this.now();
+    const open = this.since === 0 ? 0 : Math.max(0, now - this.since);
+    const busy = this.kind === "sys" ? Math.min(open, SYS_CAP_US) : 0;
+    const sys = this.sys + busy;
+    const idle = this.idle + (open - busy) + localIdle(this.sab, now).idle;
+    const user = Math.max(0, now - this.start - sys - idle);
+    this.last = {
+      utime: Math.max(this.last.utime, Math.floor(user / 1e3)),
+      stime: Math.max(this.last.stime, Math.floor(sys / 1e3))
+    };
+    return this.last;
+  }
+  add(micros) {
+    const spent = Math.max(0, micros);
+    const busy = this.kind === "sys" ? Math.min(spent, SYS_CAP_US) : 0;
+    this.sys += busy;
+    this.idle += spent - busy;
+  }
+};
+var ProcessClocks = class {
+  main;
+  threads = /* @__PURE__ */ new Map();
+  ended = { utime: 0, stime: 0 };
+  enabled;
+  constructor(sab, enabled = true, states) {
+    this.main = new CpuClock(sab);
+    this.enabled = enabled;
+    states?.onState((state) => this.stop(state === "stopped"));
+  }
+  thread(tid, sab) {
+    const clock = new CpuClock(sab);
+    this.threads.set(tid, clock);
+    return clock;
+  }
+  threadEnded(tid) {
+    const spent = this.threads.get(tid)?.times();
+    this.threads.delete(tid);
+    if (!spent) return;
+    this.ended.utime += spent.utime;
+    this.ended.stime += spent.stime;
+  }
+  stop(stopped) {
+    for (const c of this.all()) c.stop(stopped);
+  }
+  freeze() {
+    for (const c of this.all()) c.freeze();
+  }
+  times() {
+    if (!this.enabled) return void 0;
+    const sum = { ...this.ended };
+    for (const c of this.all()) {
+      const t = c.times();
+      sum.utime += t.utime;
+      sum.stime += t.stime;
+    }
+    return sum;
+  }
+  running() {
+    return this.enabled ? this.all().filter((c) => c.running()).length : 0;
+  }
+  timed(clock, dispatch2) {
+    const c = clock ?? this.main;
+    return (req) => {
+      c.enter(req.op);
+      return dispatch2(req).finally(() => c.leave());
+    };
+  }
+  all() {
+    return [this.main, ...this.threads.values()];
+  }
+};
+
 // src/kernel/net/loopback-names.ts
 var HOST_LOOPBACK = "host.slicc.internal";
 var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
@@ -7239,9 +7386,9 @@ var Pages = class {
       const page = (start2 + at) / PAGE;
       if (this.pages.has(page)) continue;
       const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
-      const fresh = this.take(part.length);
-      fresh.set(part);
-      this.pages.set(page, fresh);
+      const fresh2 = this.take(part.length);
+      fresh2.set(part);
+      this.pages.set(page, fresh2);
     }
   }
   read(at, length2) {
@@ -7467,8 +7614,8 @@ function pidStat(info, boot) {
     0,
     0,
     0,
-    0,
-    0,
+    ticks(info.utime ?? 0),
+    ticks(info.stime ?? 0),
     0,
     0,
     20,
@@ -7562,19 +7709,23 @@ function systemFile(name2, listing, now, memory) {
   if (name2 === "meminfo") {
     return memoryInfo(
       memory,
-      listing.processes.reduce((sum, p) => sum + p.memory, 0)
+      listing.processes.reduce((sum2, p) => sum2 + p.memory, 0)
     );
   }
   const live = listing.processes.filter((p) => p.state !== "Z");
   if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
-    return `0.00 0.00 0.00 1/${live.length} ${last}
+    const [one, five, fifteen] = (listing.load ?? [0, 0, 0]).map((n) => n.toFixed(2));
+    return `${one} ${five} ${fifteen} 1/${live.length} ${last}
 `;
   }
-  const idle = ticks(now - listing.boot);
+  const sum = (key) => listing.cpu?.[key] ?? listing.processes.reduce((n, p) => n + (p[key] ?? 0), 0);
+  const user = ticks(sum("utime"));
+  const system = ticks(sum("stime"));
+  const idle = listing.cpu ? ticks(listing.cpu.idle) : Math.max(0, ticks(now - listing.boot) - user - system);
   return [
-    `cpu  0 0 0 ${idle} 0 0 0 0 0 0`,
-    `cpu0 0 0 0 ${idle} 0 0 0 0 0 0`,
+    `cpu  ${user} 0 ${system} ${idle} 0 0 0 0 0 0`,
+    `cpu0 ${user} 0 ${system} ${idle} 0 0 0 0 0 0`,
     "intr 0",
     "ctxt 0",
     `btime ${Math.floor(listing.boot / 1e3)}`,
@@ -11340,10 +11491,10 @@ var WasmProcess = class {
         this.fds.installAt(fd, this.openVfsFile(open));
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
-          const fresh = this.options.owners && !await present2(this.options.fs, path, true);
+          const fresh2 = this.options.owners && !await present2(this.options.fs, path, true);
           this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
           await this.fds.get(fd).file.stat?.();
-          if (fresh) await this.options.fs.chown?.(path, { ...this.newOwner(), kind: "new" });
+          if (fresh2) await this.options.fs.chown?.(path, { ...this.newOwner(), kind: "new" });
         });
       } else {
         this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
@@ -12034,6 +12185,9 @@ function killThread(thread, caught, sig) {
   blocked.abort();
   return true;
 }
+function threadSignalsOf(sab) {
+  return { header: new Int32Array(sab, 0, SAB_HEADER_I32), interrupt: new AbortController() };
+}
 function threadCancel(thread) {
   return Atomics.load(thread.header, SAB_I_SIGNALS) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
 }
@@ -12159,6 +12313,22 @@ function processOptions(opts, header4, hooks, created3) {
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header4, SAB_I_SIGNALS) } : {}
   };
 }
+function threadInit(opts, program, sab, cred, thread) {
+  return {
+    type: WASM_THREAD_INIT,
+    pid: opts.shownPid ?? opts.pid,
+    program,
+    argv0: opts.argv0,
+    args: opts.args,
+    env: opts.env,
+    cwd: opts.cwd,
+    sab,
+    cred: copyCred(cred),
+    owners: opts.owners === true,
+    ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
+    thread
+  };
+}
 function spawnWasmProcess(opts) {
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header4 = new Int32Array(sab, 0, SAB_HEADER_I32);
@@ -12191,7 +12361,10 @@ function spawnWasmProcess(opts) {
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process2.syscall(req) : dispatchSyncFs(req));
-  const responder = attachSyncSabResponder(worker, sab, token, { dispatch: dispatch2 });
+  const clocks = new ProcessClocks(sab, opts.program.abi !== "js", process2);
+  const responder = attachSyncSabResponder(worker, sab, token, {
+    dispatch: clocks.timed(void 0, dispatch2)
+  });
   const lane = opts.program.abi === "js" ? openLane(token, dispatch2) : void 0;
   const { promise: exited, resolve: settle } = Promise.withResolvers();
   let done4 = false;
@@ -12199,6 +12372,7 @@ function spawnWasmProcess(opts) {
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    clocks.freeze();
     dying.clear();
     endedBy = sig ?? process2.execTermsig;
     worker.removeEventListener("message", onMessage);
@@ -12239,6 +12413,7 @@ function spawnWasmProcess(opts) {
   const endThread = (tid) => {
     const end = threads.get(tid);
     threads.delete(tid);
+    clocks.threadEnded(tid);
     process2.threadEnded(tid);
     end?.();
   };
@@ -12252,15 +12427,14 @@ function spawnWasmProcess(opts) {
     }
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
-    const tsignals = {
-      header: new Int32Array(tsab, 0, SAB_HEADER_I32),
-      interrupt: new AbortController()
-    };
+    const tsignals = threadSignalsOf(tsab);
     threadSignals.set(thread.tid, tsignals);
     const tdispatch = (req) => dying.serving(
       () => isWasmSyscall(req) ? process2.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
     );
-    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: tdispatch });
+    const tresponder = attachSyncSabResponder(tw, tsab, token, {
+      dispatch: clocks.timed(clocks.thread(thread.tid, tsab), tdispatch)
+    });
     const onThreadMessage = (event) => {
       const data = event.data;
       if (data?.type === WASM_THREAD_EXIT) endThread(thread.tid);
@@ -12275,21 +12449,7 @@ function spawnWasmProcess(opts) {
       tresponder.dispose();
       tw.terminate();
     });
-    const tinit = {
-      type: WASM_THREAD_INIT,
-      pid: opts.shownPid ?? opts.pid,
-      program,
-      argv0: opts.argv0,
-      args: opts.args,
-      env: opts.env,
-      cwd: opts.cwd,
-      sab: tsab,
-      cred: copyCred(process2.cred),
-      owners: opts.owners === true,
-      ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
-      thread
-    };
-    tw.postMessage(tinit);
+    tw.postMessage(threadInit(opts, program, tsab, process2.cred, thread));
   };
   worker.postMessage(
     processInit(opts, sab, process2.umask, copyCred(process2.cred), lane?.lane),
@@ -12314,7 +12474,9 @@ function spawnWasmProcess(opts) {
     signalMasks: () => process2.signalMasks(),
     umask: () => process2.umask,
     cred: () => copyCred(process2.cred),
-    writesBack: () => opts.program.abi === "wasi" && !done4
+    writesBack: () => opts.program.abi === "wasi" && !done4,
+    times: () => clocks.times(),
+    running: () => clocks.running()
   };
 }
 
@@ -12787,7 +12949,7 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
       (result) => {
         if (result instanceof Uint8Array) {
           const whole = result.byteOffset === 0 && result.byteLength === result.buffer.byteLength;
-          const bytes = options.owned && whole ? result : result.slice();
+          const bytes = options.owned && whole ? result : fresh(result);
           reply({ id: data.id, result: bytes }, [bytes.buffer]);
         } else reply({ id: data.id, result: result ?? null });
       },
@@ -13275,14 +13437,14 @@ var RESTORE_AGAIN_MS = 3e4;
 function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
   const handles = /* @__PURE__ */ new Map();
   let nextFh = 0;
-  const fresh = (remote) => {
+  const fresh2 = (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) => {
     const remote = handles.get(fh);
     if (!remote) throw fsError2("EBADF", `handle ${fh}`);
-    return fresh(remote);
+    return fresh2(remote);
   };
   const call = (op, body = {}) => current().call(op, body);
   const same = (was, mode, seen) => seen?.mode === (mode | 128) && (was.ino !== void 0 && seen.ino !== void 0 ? seen.ino === was.ino : seen.size === was.size && seen.mtime === was.mtime);
@@ -13364,7 +13526,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       if (!remote) throw fsError2("EBADF", `handle ${fh}`);
       handles.delete(fh);
       try {
-        await fresh(remote).client.call("release", { fh: remote.fh }, true);
+        await fresh2(remote).client.call("release", { fh: remote.fh }, true);
       } finally {
         if (remote.restore) await settle(current(), remote.restore);
       }
@@ -14733,6 +14895,8 @@ var LAYOUT = [
   ["/usr", 493],
   ["/usr/local", 493]
 ];
+var LOAD_SAMPLE_MS = 5e3;
+var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
 var encoder3 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
@@ -15261,6 +15425,7 @@ var Launcher = class {
     return this.jobs.sessionOf(pgid);
   }
   start(req) {
+    this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
       throw fsError("ESRCH", `no process group ${req.pgid}`);
     }
@@ -15301,7 +15466,12 @@ var Launcher = class {
       forker: this.forker(pid, req),
       kill: (target, sig) => this.kill(target, sig, this.credOf(pid), pid),
       writesBack: (target) => this.processes.get(target)?.writesBack() === true,
-      processes: () => ({ boot: this.boot, processes: this.list(this.credOf(pid)) }),
+      processes: () => ({
+        boot: this.boot,
+        processes: this.list(this.credOf(pid)),
+        load: this.loadAverage(),
+        cpu: this.cpuTotal()
+      }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       openFiles: this.openFiles,
       nodes: this.nodes,
@@ -15335,7 +15505,14 @@ var Launcher = class {
       started: Date.now()
     });
     void handle.exited.then(() => {
+      const spent = handle.times?.();
+      if (spent) this.spent.set(pid, spent);
       this.processes.delete(pid);
+      if (this.processes.size === 0) {
+        clearInterval(this.sampler);
+        this.sampler = void 0;
+        this.idleSince = Date.now();
+      }
       this.settling.settled(pid);
       if (req.ppid === void 0 || this.orphans.delete(pid)) this.forget(pid);
       else this.zombies.add(pid);
@@ -15351,6 +15528,12 @@ var Launcher = class {
   forget(pid) {
     this.jobs.remove(pid);
     this.described.delete(pid);
+    const spent = this.spent.get(pid);
+    if (spent) {
+      this.reapedTimes.utime += spent.utime;
+      this.reapedTimes.stime += spent.stime;
+    }
+    this.spent.delete(pid);
     this.creds.delete(pid);
     this.tags.delete(pid);
     this.granted.delete(pid);
@@ -15359,6 +15542,70 @@ var Launcher = class {
     if (this.zombies.delete(pid)) this.forget(pid);
     else this.orphans.add(pid);
   }
+  load = [0, 0, 0];
+  sampler;
+  reapedTimes = { utime: 0, stime: 0 };
+  idleAt = { wall: this.boot, busy: 0, idle: 0 };
+  cpuTotal(now = Date.now()) {
+    const total = { ...this.reapedTimes };
+    const add = (t) => {
+      total.utime += t?.utime ?? 0;
+      total.stime += t?.stime ?? 0;
+    };
+    for (const handle of this.processes.values()) add(handle.times?.());
+    for (const t of this.spent.values()) add(t);
+    const busy = total.utime + total.stime;
+    const at = this.idleAt;
+    at.idle += Math.max(0, now - at.wall - (busy - at.busy));
+    at.wall = Math.max(at.wall, now);
+    at.busy = Math.max(at.busy, busy);
+    return { ...total, idle: at.idle };
+  }
+  loadAverage() {
+    return this.load;
+  }
+  sampledAt = Date.now();
+  sampleLoad(now = Date.now()) {
+    let running = 0;
+    for (const handle of this.processes.values()) running += handle.running?.() ?? 0;
+    const elapsed = Math.max(LOAD_SAMPLE_MS, now - this.sampledAt);
+    this.sampledAt = Math.max(this.sampledAt, now);
+    this.load = this.load.map((avg, i) => {
+      const window = LOAD_WINDOWS_MS[i];
+      const fresh2 = 1 - Math.exp(-LOAD_SAMPLE_MS / window);
+      return avg * Math.exp(-elapsed / window) + running * fresh2;
+    });
+  }
+  idleSince;
+  sampling() {
+    if (this.sampler) return;
+    if (this.idleSince !== void 0) {
+      const empty = Math.max(0, Date.now() - this.idleSince);
+      this.load = this.load.map(
+        (avg, i) => avg * Math.exp(-empty / LOAD_WINDOWS_MS[i])
+      );
+    }
+    this.sampledAt = Date.now();
+    this.sampler = setInterval(() => this.sampleLoad(), LOAD_SAMPLE_MS);
+    this.sampler.unref?.();
+  }
+  spent = /* @__PURE__ */ new Map();
+  timesAt(pid) {
+    return this.processes.get(pid)?.times?.() ?? this.spent.get(pid);
+  }
+  timesOf(member, members) {
+    let utime = 0;
+    let stime = 0;
+    let timed2 = false;
+    for (let at = member; at; at = members.get(at.execParent ?? -1)) {
+      const t = this.timesAt(at.pid);
+      if (!t) continue;
+      timed2 = true;
+      utime += t.utime;
+      stime += t.stime;
+    }
+    return timed2 ? { utime, stime } : {};
+  }
   list(viewer = ROOT) {
     const members = new Map(this.jobs.list().map((member) => [member.pid, member]));
     const rootOf = (member) => {
@@ -15390,6 +15637,7 @@ var Launcher = class {
         started: (this.described.get(root.pid) ?? described2).started,
         state: this.processes.has(member.pid) ? "S" : "Z",
         memory: this.processes.get(member.pid)?.memory() ?? 0,
+        ...this.timesOf(member, members),
         umask: this.umaskOf(member.pid),
         cred,
         ...this.signalMasksOf(member.pid)
@@ -15649,8 +15897,8 @@ var Launcher = class {
     ];
     for (const [path, mode] of layout) {
       const real = await this.realLayoutPath(path);
-      const fresh = real !== void 0 && !await this.base.hasOwner?.(real);
-      if (fresh) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
+      const fresh2 = real !== void 0 && !await this.base.hasOwner?.(real);
+      if (fresh2) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
     }
   }
   async realLayoutPath(given) {
@@ -16395,7 +16643,7 @@ function dialStream(port, onClose) {
   const writable2 = new WritableStream({
     write(chunk2) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
-      const copy = chunk2.slice();
+      const copy = fresh(chunk2);
       const acked = new Promise((resolve, reject) => acks.push({ resolve, reject }));
       port.postMessage(copy, [copy.buffer]);
       return acked;