@ai-ecoverse/slicc-kernel 1.93.2 → 1.94.0

package/dist/node.js

@@ -6158,10 +6158,15 @@ async function binCommandsOf(physical, pkg, manifest, taken) {
   }
   return out;
 }
-async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY) {
-  const found = /* @__PURE__ */ new Map();
-  const physical = physicalResolver(fs);
-  for (const [index, root] of (typeof modules === "string" ? [modules] : modules).entries()) {
+var PACKAGE_NAME = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+function replacesOf(manifest) {
+  const replaces = manifest.slicc?.replaces;
+  if (!Array.isArray(replaces)) return [];
+  return replaces.every((name2) => typeof name2 === "string" && PACKAGE_NAME.test(name2)) ? replaces : [];
+}
+async function tierPackages(fs, physical, roots, bins) {
+  const out = [];
+  for (const root of roots) {
     for (const pkg of await packages(fs, root)) {
       let manifest;
       try {
@@ -6171,11 +6176,47 @@ async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY) {
       }
       const own = commandsOf(pkg, manifest);
       const named = new Set(own.map((command) => command.name));
-      const bins = index >= binsFrom ? await binCommandsOf(physical, pkg, manifest, named) : [];
-      for (const command of [...own, ...bins]) {
-        if (!found.has(command.name))
-          found.set(command.name, await withPackagePaths(fs, pkg, command));
-      }
+      const extra = bins ? await binCommandsOf(physical, pkg, manifest, named) : [];
+      out.push({
+        name: pkg.slice(root.length + 1),
+        pkg,
+        replaces: replacesOf(manifest),
+        commands: [...own, ...extra]
+      });
+    }
+  }
+  return out;
+}
+function winners(tier) {
+  const providers = /* @__PURE__ */ new Map();
+  for (const entry of tier) {
+    for (const command of entry.commands) {
+      const list = providers.get(command.name) ?? [];
+      if (!list.includes(entry)) list.push(entry);
+      providers.set(command.name, list);
+    }
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [name2, list] of providers) {
+    const kept = list.filter(
+      (entry2) => !list.some((other) => other !== entry2 && other.replaces.includes(entry2.name))
+    );
+    const entry = kept[0] ?? list[0];
+    const command = entry.commands.find((c) => c.name === name2);
+    out.set(name2, { pkg: entry.pkg, command });
+  }
+  return out;
+}
+async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY) {
+  const found = /* @__PURE__ */ new Map();
+  const physical = physicalResolver(fs);
+  const tiers = (typeof modules === "string" ? [modules] : modules).map(
+    (tier) => typeof tier === "string" ? [tier] : tier
+  );
+  for (const [index, roots] of tiers.entries()) {
+    const tier = await tierPackages(fs, physical, roots, index >= binsFrom);
+    for (const [name2, { pkg, command }] of winners(tier)) {
+      if (!found.has(name2)) found.set(name2, await withPackagePaths(fs, pkg, command));
     }
   }
   if (!found.has("sh") && found.has("bash")) {
@@ -8279,7 +8320,7 @@ function statOf(attr2, path, mount) {
     size: attr2.size,
     mode: attr2.mode ?? fallback,
     mtime,
-    atime: mtime,
+    atime: attr2.atime === void 0 ? mtime : new Date(attr2.atime),
     ctime: mtime,
     ino: attr2.ino ?? inodeOf(path),
     ...!inodeless(mount, attr2) && attr2.nlink !== void 0 ? { nlink: attr2.nlink } : {},
@@ -9324,7 +9365,7 @@ var MountFs = class _MountFs {
         ([to], n) => this.utimes(to, atime, mtime, n)
       );
     }
-    await this.setMtime(found, real, mtime);
+    await this.setTimes(found, real, atime, mtime);
   }
   async lutimes(path, atime, mtime, redirects = 0) {
     const found = this.at(path);
@@ -9341,12 +9382,13 @@ var MountFs = class _MountFs {
     if (!found.mount.caps.linkTimes && (await this.lstat(real)).isSymbolicLink) {
       throw errnoError("EOPNOTSUPP", path);
     }
-    await this.setMtime(found, real, mtime);
+    await this.setTimes(found, real, atime, mtime);
   }
-  async setMtime(found, real, mtime) {
+  async setTimes(found, real, atime, mtime) {
     this.writable(found.mount, real);
     this.table.forget(found.mount, real);
-    await found.mount.conn.call({ op: "setattr", path: found.rel, mtime: mtime.getTime() });
+    const times = { mtime: mtime.getTime(), atime: atime.getTime() };
+    await found.mount.conn.call({ op: "setattr", path: found.rel, ...times });
   }
   noLinks() {
     const noLinkBase = this.base.noLinks.call(this.base);
@@ -10108,14 +10150,6 @@ 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 BLOCKED = 0;
@@ -10147,9 +10181,16 @@ var CpuClock = class {
     this.now = now;
     this.start = now();
   }
-  enter(op) {
+  enter() {
     this.since = this.now();
-    this.kind = this.stopped || IDLE_OPS.has(op) ? "idle" : "sys";
+    this.kind = this.stopped ? "idle" : "sys";
+  }
+  block() {
+    if (this.since === 0 || this.kind === "idle" || this.frozen !== void 0) return;
+    const now = this.now();
+    this.add(now - this.since);
+    this.since = now;
+    this.kind = "idle";
   }
   leave() {
     if (this.since === 0) return;
@@ -10239,9 +10280,10 @@ var ProcessClocks = class {
   }
   timed(clock, dispatch2) {
     const c = clock ?? this.main;
+    const block = () => c.block();
     return (req) => {
-      c.enter(req.op);
-      return dispatch2(req).finally(() => c.leave());
+      c.enter();
+      return dispatch2(req, block).finally(() => c.leave());
     };
   }
   all() {
@@ -10500,7 +10542,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.93.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.94.0" : "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
@@ -14192,7 +14234,8 @@ var WasmProcess = class {
     this.wake?.();
     for (const listener of this.stateListeners) listener("continued", SIG.CONT);
   }
-  async syscall(req, cancelled) {
+  blocks = /* @__PURE__ */ new WeakMap();
+  async syscall(req, cancelled, block) {
     this.options.onSyscall?.(req);
     for (; ; ) {
       await this.resumed;
@@ -14202,6 +14245,7 @@ var WasmProcess = class {
       const forward = () => scope.abort();
       if (cancelled?.aborted) scope.abort();
       cancelled?.addEventListener("abort", forward, { once: true });
+      if (block) this.blocks.set(scope.signal, block);
       const result = await this.dispatch(req, scope.signal).finally(() => {
         cancelled?.removeEventListener("abort", forward);
         this.waiting.delete(scope.signal);
@@ -14284,6 +14328,7 @@ var WasmProcess = class {
     }
     if (this.options.hasPending?.() || cancelled.aborted) throw new KernelError("EINTR");
     if (owing) this.waiting.add(cancelled);
+    if (owing) this.blocks.get(cancelled)?.();
     return this.cancelSignal(cancelled);
   }
   cancelSignal(cancelled) {
@@ -14925,6 +14970,7 @@ var WasmProcess = class {
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
+        this.blocks.get(cancelled)?.();
         this.adoptExec(req.pid);
         this.options.jobs?.exec(this.pid, req.pid);
         await this.fds.closeAll();
@@ -15255,6 +15301,9 @@ function killThread(thread, caught, sig) {
 function unblocked(header4) {
   return Atomics.load(header4, SAB_I_SIGNALS) & ~Atomics.load(header4, SAB_I_BLOCKED);
 }
+function threadCall(process2, req, cancelled, block) {
+  return isWasmSyscall(req) ? process2.syscall(req, cancelled, block) : dispatchSyncFs(req);
+}
 function threadSignalsOf(sab) {
   return { header: new Int32Array(sab, 0, SAB_HEADER_I32), interrupt: new AbortController() };
 }
@@ -15458,7 +15507,9 @@ function spawnWasmProcess(opts) {
   process2.keptHandle = (handle2) => holds.keptFor(handle2)?.hidden;
   const worker = opts.createWorker();
   const dying = new Dying();
-  const dispatch2 = (req) => dying.serving(() => isWasmSyscall(req) ? process2.syscall(req) : dispatchSyncFs(req));
+  const dispatch2 = (req, block) => dying.serving(
+    () => isWasmSyscall(req) ? process2.syscall(req, void 0, block) : dispatchSyncFs(req)
+  );
   const clocks = new ProcessClocks(sab, opts.program.abi !== "js", process2);
   const responder = attachSyncSabResponder(worker, sab, token, {
     dispatch: clocks.timed(void 0, dispatch2)
@@ -15528,9 +15579,7 @@ function spawnWasmProcess(opts) {
     const tsignals = threadSignalsOf(tsab);
     if (thread.blocked) storeBlocked(tsignals.header, thread.blocked);
     threadSignals.set(thread.tid, tsignals);
-    const tdispatch = (req) => dying.serving(
-      () => isWasmSyscall(req) ? process2.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
-    );
+    const tdispatch = (req, block) => dying.serving(() => threadCall(process2, req, threadCancel(tsignals), block));
     const tresponder = attachSyncSabResponder(tw, tsab, token, {
       dispatch: clocks.timed(clocks.thread(thread.tid, tsab), tdispatch)
     });
@@ -16786,6 +16835,12 @@ function withOwner(base, owner) {
 function fsError2(code, message3 = code) {
   return Object.assign(new Error(message3), { code });
 }
+var SET_ATTRS = ["mode", "mtime", "atime", "size", "uid", "gid"];
+function setAttrOf(req) {
+  const attr2 = {};
+  for (const key of SET_ATTRS) if (req[key] !== void 0) attr2[key] = req[key];
+  return attr2;
+}
 async function dispatch(h, req) {
   switch (req.op) {
     case "getattr":
@@ -16830,13 +16885,7 @@ async function dispatch(h, req) {
       if (!h.readlink) throw fsError2("EINVAL", `${req.path} is not a symlink`);
       return h.readlink(req.path);
     case "setattr":
-      return h.setattr?.(req.path, {
-        ...req.mode !== void 0 ? { mode: req.mode } : {},
-        ...req.mtime !== void 0 ? { mtime: req.mtime } : {},
-        ...req.size !== void 0 ? { size: req.size } : {},
-        ...req.uid !== void 0 ? { uid: req.uid } : {},
-        ...req.gid !== void 0 ? { gid: req.gid } : {}
-      });
+      return h.setattr?.(req.path, setAttrOf(req));
     case "statfs":
       return h.statfs?.() ?? null;
     default:
@@ -18048,11 +18097,13 @@ function idOption2(value) {
   return value !== void 0 && /^\d+$/.test(value) ? Number(value) : 0;
 }
 function created2(ino, kind, mode, from, owner) {
+  const now = Date.now();
   return {
     kind,
     ino,
     mode: owner?.mode === void 0 ? mode : mode & ~4095 | owner.mode & 4095,
-    mtime: Date.now(),
+    mtime: now,
+    atime: now,
     data: new ChunkedBytes(),
     target: "",
     children: /* @__PURE__ */ new Map(),
@@ -18070,6 +18121,7 @@ function attr(node) {
     kind: node.kind,
     size: node.kind === "file" ? node.data.size : node.kind === "symlink" ? node.target.length : 4096,
     mtime: node.mtime,
+    atime: node.atime,
     mode: node.mode,
     ino: node.ino,
     ...node.kind === "directory" ? {} : { nlink: node.links },
@@ -18232,6 +18284,7 @@ function tmpfs() {
         node.mtime = Date.now();
       }
       if (change.mtime !== void 0) node.mtime = change.mtime;
+      if (change.atime !== void 0) node.atime = change.atime;
       owned3(node, change);
     },
     async statfs() {
@@ -19251,8 +19304,8 @@ var Launcher = class {
     let found = this.catalogs.get(scope);
     if (!found) {
       found = this.trustedAppended().then(async (appended) => {
-        const roots = await this.roots(scope, appended);
-        return scanCommands(this.scanned, roots, roots.length - appended.length);
+        const tiers = await this.tiers(scope, appended);
+        return scanCommands(this.scanned, tiers, tiers.length - appended.length);
       }).then((commands) => commands.set(SUDO_COMMAND.name, SUDO_COMMAND));
       this.catalogs.set(scope, found);
     }
@@ -19280,13 +19333,16 @@ var Launcher = class {
     }
     return found;
   }
-  async roots(scope = "", appended) {
+  async tiers(scope = "", appended) {
     const system = [
-      this.modulesDir,
-      ...await pnpmGlobalRoots(this.base, this.pnpmHome),
-      ...appended ?? await this.trustedAppended()
+      [this.modulesDir],
+      await pnpmGlobalRoots(this.base, this.pnpmHome),
+      ...(appended ?? await this.trustedAppended()).map((root) => [root])
     ];
-    return scope ? [...await pnpmGlobalRoots(this.base, scope), ...system] : system;
+    return scope ? [await pnpmGlobalRoots(this.base, scope), ...system] : system;
+  }
+  async roots(scope = "") {
+    return (await this.tiers(scope)).flat();
   }
   async rootOnlyPath(root) {
     for (const at of chain(root)) {
@@ -20898,6 +20954,17 @@ function proxyAddresses() {
   }
   return out;
 }
+var proxied = /* @__PURE__ */ new Set();
+function tupleOf(socket) {
+  if (!socket.localPort || !socket.remotePort) return void 0;
+  return `${socket.localAddress}:${socket.localPort} ${socket.remoteAddress}:${socket.remotePort}`;
+}
+function toProxy(connectParams) {
+  const proxies = proxyAddresses();
+  if (proxies.size === 0 || !connectParams.hostname) return false;
+  const port = connectParams.port || (connectParams.protocol === "https:" ? "443" : "80");
+  return proxies.has(`${connectParams.hostname}:${port}`);
+}
 function ensureSubscribed() {
   if (subscribed) return;
   subscribed = true;
@@ -20912,10 +20979,14 @@ function ensureSubscribed() {
       socket.destroy(err2);
       return;
     }
-    const proxies = proxyAddresses();
-    if (proxies.size > 0 && connectParams.hostname) {
-      const cpPort = connectParams.port || (connectParams.protocol === "https:" ? "443" : "80");
-      if (proxies.has(`${connectParams.hostname}:${cpPort}`)) return;
+    const tuple = tupleOf(socket);
+    if (tuple && proxied.has(tuple)) return;
+    if (toProxy(connectParams)) {
+      if (tuple) {
+        proxied.add(tuple);
+        socket.once("close", () => proxied.delete(tuple));
+      }
+      return;
     }
     const place = placeOf(address);
     if (!place) return;