@ai-ecoverse/slicc-kernel 1.93.3 → 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")) {
@@ -10109,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;
@@ -10148,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;
@@ -10240,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() {
@@ -10501,7 +10542,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.93.3" : "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
@@ -14193,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;
@@ -14203,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);
@@ -14285,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) {
@@ -14926,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();
@@ -15256,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() };
 }
@@ -15459,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)
@@ -15529,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)
     });
@@ -19256,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);
     }
@@ -19285,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)) {
@@ -20903,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;
@@ -20917,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;