@ai-ecoverse/slicc-kernel 1.170.1 → 1.170.3

package/dist/node-process-worker.cjs

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

package/dist/node-process-worker.js

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

package/dist/node.js

@@ -3695,7 +3695,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.170.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.170.3" : "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
@@ -3964,9 +3964,19 @@ function replacesOf(manifest) {
   if (!Array.isArray(replaces)) return [];
   return replaces.every((name2) => typeof name2 === "string" && PACKAGE_NAME.test(name2)) ? replaces : [];
 }
-async function tierPackages(fs, physical, roots, bins, kernel) {
+async function directInstalls(fs, root) {
+  try {
+    const project = root.slice(0, root.lastIndexOf("/"));
+    const { dependencies } = JSON.parse(await fs.readFile(`${project}/package.json`));
+    return new Set(Object.keys(dependencies ?? {}));
+  } catch {
+    return void 0;
+  }
+}
+async function tierPackages(fs, physical, roots, bins, kernel, global) {
   const out = [];
   for (const root of roots) {
+    const direct = global.has(root) ? await directInstalls(fs, root) : void 0;
     for (const pkg of await packages(fs, root)) {
       let manifest;
       try {
@@ -3978,12 +3988,15 @@ async function tierPackages(fs, physical, roots, bins, kernel) {
       const named = new Set(own.map((command) => command.name));
       const extra = bins ? await binCommandsOf(physical, pkg, manifest, named) : [];
       const refused3 = engineRefusal(manifest, kernel);
-      const commands = [...own, ...extra];
+      const name2 = pkg.slice(root.length + 1);
+      const dependency = direct?.has(name2) === false;
+      const marks = { ...refused3 ? { refused: refused3 } : {}, ...dependency ? { dependency } : {} };
       out.push({
-        name: pkg.slice(root.length + 1),
+        name: name2,
         pkg,
         replaces: replacesOf(manifest),
-        commands: refused3 ? commands.map((command) => ({ ...command, refused: refused3 })) : commands
+        commands: [...own, ...extra].map((command) => ({ ...command, ...marks })),
+        dependency
       });
     }
   }
@@ -4009,19 +4022,25 @@ function winners(tier) {
   }
   return out;
 }
-async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY, kernel = KERNEL_VERSION, refused3) {
+async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY, kernel = KERNEL_VERSION, refused3, global = /* @__PURE__ */ new Set()) {
   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, kernel);
-    if (refused3) refused3.push(...tier.flatMap((entry) => entry.commands.filter((c) => c.refused)));
+  const take = async (tier) => {
     for (const [name2, { pkg, command }] of winners(tier)) {
       if (!found.has(name2)) found.set(name2, await withPackagePaths(fs, pkg, command));
     }
+  };
+  const dependencies = [];
+  for (const [index, roots] of tiers.entries()) {
+    const tier = await tierPackages(fs, physical, roots, index >= binsFrom, kernel, global);
+    if (refused3) refused3.push(...tier.flatMap((entry) => entry.commands.filter((c) => c.refused)));
+    await take(tier.filter((entry) => !entry.dependency));
+    dependencies.push(tier.filter((entry) => entry.dependency));
   }
+  for (const tier of dependencies) await take(tier);
   if (!found.has("sh") && found.has("bash")) {
     found.set("sh", { ...found.get("bash"), name: "sh", argv0: "sh" });
   }
@@ -4975,7 +4994,8 @@ var UnlinkedKeeper = class {
     if (at !== void 0 || !await this.present(path)) return at;
     throw fsError("EBUSY", `${path}: open, and it could not be kept aside`);
   }
-  present(path) {
+  async present(path) {
+    if (await this.fs.commandTarget?.(path)) return false;
     return this.fs.lstat(path).then(
       () => true,
       (err) => err?.code !== "ENOENT" && err?.code !== "ENOTDIR"
@@ -7847,8 +7867,9 @@ var FsWatchers = class {
     this.report(paths);
     this.emit("change", paths);
   }
-  report(paths) {
+  report(paths, notify = true) {
     for (const tap of this.taps) tap(paths);
+    if (!notify) return;
     for (const watcher of this.watchers) {
       for (const path of paths) {
         const changed = normalizePath(path);
@@ -7867,16 +7888,16 @@ var FsWatchers = class {
     watcher.notify(paths.length > WATCH_BATCH_LIMIT ? { overflow: true } : { paths });
   }
   wrap(fs) {
-    const after = (run2, changed, type) => async (...args) => {
-      let done4 = false;
+    const after = (run2, changed, type, partly = () => false) => async (...args) => {
       try {
         await run2(...args);
-        done4 = true;
-      } finally {
-        const paths = changed(...args);
-        this.report(paths);
-        if (done4) this.emit(type, paths);
+      } catch (err) {
+        this.report(changed(...args), partly(err, ...args));
+        throw err;
       }
+      const paths = changed(...args);
+      this.report(paths);
+      this.emit(type, paths);
     };
     const reals = this.reals;
     const realOf = async (path) => {
@@ -7918,6 +7939,12 @@ var FsWatchers = class {
         this.reshaped();
       }
     };
+    const removing = after(
+      fs.rm.bind(fs),
+      (path) => [path],
+      "rename",
+      (err, _path, options) => options?.recursive === true && err?.code !== "ENOENT"
+    );
     const overrides = {
       writeFile: content(fs.writeFile.bind(fs), overwritten),
       ...fs.createExclusive ? { createExclusive: content(fs.createExclusive.bind(fs), () => ["rename"]) } : {},
@@ -7946,14 +7973,20 @@ var FsWatchers = class {
           if (done4) this.emit("rename", fresh3 ? [...created4, path] : created4);
         }
       },
-      rm: reshaping(after(fs.rm.bind(fs), (path) => [path], "rename")),
+      rm: reshaping(async (path, options) => {
+        const absent2 = options?.force === true && await fs.lstat(path).then(
+          () => false,
+          () => true
+        );
+        return absent2 ? fs.rm(path, options) : removing(path, options);
+      }),
       rename: reshaping(async (from, to) => {
         let done4 = false;
         try {
           await fs.rename(from, to);
           done4 = true;
         } finally {
-          this.report([from, to]);
+          this.report([from, to], done4);
           if (done4) this.renamed(from, to);
         }
       }),
@@ -31118,7 +31151,8 @@ var Launcher = class {
           tiers,
           tiers.length - appended2.length,
           void 0,
-          refused3
+          refused3,
+          await this.globalRoots(scope)
         );
         this.refusedOf.set(commands, refused3.map(refusing));
         return commands;
@@ -31143,11 +31177,31 @@ var Launcher = class {
   ownCommands(scope) {
     let found = this.ownCatalogs.get(scope);
     if (!found) {
-      found = pnpmGlobalRoots(this.base, scope).then((roots) => scanCommands(this.scanned, roots)).then((commands) => new Set(commands.keys()));
+      found = this.ownCatalog(scope);
       this.ownCatalogs.set(scope, found);
     }
     return found;
   }
+  async ownCatalog(scope) {
+    const roots = await pnpmGlobalRoots(this.base, scope);
+    const own = await scanCommands(
+      this.scanned,
+      roots,
+      void 0,
+      void 0,
+      void 0,
+      new Set(roots)
+    );
+    const system = await this.commands();
+    return new Set(
+      [...own.values()].filter((command) => !command.dependency || !system.has(command.name)).map((command) => command.name)
+    );
+  }
+  async globalRoots(scope) {
+    const homes = scope ? [scope, this.pnpmHome] : [this.pnpmHome];
+    const roots = await Promise.all(homes.map((home) => pnpmGlobalRoots(this.base, home)));
+    return new Set(roots.flat());
+  }
   interpreters(scope = "") {
     let found = this.binfmts.get(scope);
     if (!found) {