@ai-ecoverse/slicc-kernel 1.168.0 → 1.169.0

package/dist/node.js

@@ -3695,7 +3695,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.168.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.169.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
@@ -12248,6 +12248,8 @@ var SYS_TREE = {
     slicc_opfs_ops: (listing) => `${listing.opfsOps ?? 0}
 `,
     slicc_cwd_checks: (listing) => `${listing.cwdChecks ?? 0}
+`,
+    slicc_package_swaps: ({ swaps }) => `${swaps?.swaps ?? 0} ${(swaps?.longestMs ?? 0).toFixed(1)} ${swaps?.waits ?? 0} ${(swaps?.waitedMs ?? 0).toFixed(1)}
 `,
     slicc_rename_ack_busy: (listing) => `${listing.renameAcks?.busy ?? 0}
 `,
@@ -25239,6 +25241,105 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// src/kernel/package-swaps.ts
+var SWAP_GAP_MS = 2e3;
+var STAGES = ["_tmp_", "_pacquet-stage_"];
+function staged(source, target) {
+  if (parentOf(source) !== parentOf(target)) return false;
+  const name2 = target.slice(target.lastIndexOf("/") + 1);
+  const from = source.slice(source.lastIndexOf("/") + 1);
+  return from.startsWith(`.${name2}-`) || STAGES.some((stage) => from.startsWith(`${name2}${stage}`));
+}
+var PackageSwaps = class {
+  gaps = /* @__PURE__ */ new Map();
+  isRoot;
+  hold;
+  closed;
+  gapMs;
+  tally = { swaps: 0, longestMs: 0, waits: 0, waitedMs: 0 };
+  constructor(isRoot, hold, closed, gapMs = SWAP_GAP_MS) {
+    this.isRoot = isRoot;
+    this.hold = hold;
+    this.closed = closed;
+    this.gapMs = gapMs;
+  }
+  counts() {
+    return { ...this.tally };
+  }
+  settled() {
+    if (this.gaps.size === 0) return Promise.resolve();
+    const started = performance.now();
+    this.tally.waits++;
+    return Promise.all([...this.gaps.values()].map((gap) => gap.settled)).then(() => {
+      this.tally.waitedMs += performance.now() - started;
+    });
+  }
+  wrap(fs) {
+    return { ...fs, rename: (from, to) => this.rename(fs, from, to) };
+  }
+  async rename(fs, from, to) {
+    const source = fs.resolvePath("/", from);
+    const target = fs.resolvePath("/", to);
+    const gap = this.gaps.get(target);
+    if (gap) return this.land(gap, target, () => fs.rename(from, to));
+    if (source === target || this.gaps.has(source) || staged(source, target) || !this.isRoot(source)) {
+      return fs.rename(from, to);
+    }
+    const release = await this.hold(source);
+    let kept = false;
+    try {
+      await fs.rename(from, to);
+      kept = await fs.stat(`${target}/package.json`).then(
+        (st) => st.isFile,
+        () => false
+      );
+      if (kept) this.open(source, release);
+    } finally {
+      if (!kept) release();
+    }
+  }
+  open(root, release) {
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const gap = {
+      release,
+      done: () => resolve2(),
+      settled: promise,
+      timer: void 0,
+      landing: 0,
+      opened: performance.now()
+    };
+    this.gaps.set(root, gap);
+    this.tally.swaps++;
+    this.arm(root, gap);
+  }
+  arm(root, gap) {
+    const timer = setTimeout(() => this.close(root, gap), this.gapMs);
+    timer.unref?.();
+    gap.timer = timer;
+  }
+  close(root, gap) {
+    if (this.gaps.get(root) !== gap) return;
+    clearTimeout(gap.timer);
+    this.gaps.delete(root);
+    this.tally.longestMs = Math.max(this.tally.longestMs, performance.now() - gap.opened);
+    this.closed();
+    gap.done();
+    gap.release();
+  }
+  async land(gap, root, run2) {
+    gap.landing++;
+    clearTimeout(gap.timer);
+    try {
+      await run2();
+    } catch (err) {
+      gap.landing--;
+      if (gap.landing === 0 && this.gaps.get(root) === gap) this.arm(root, gap);
+      throw err;
+    }
+    this.close(root, gap);
+  }
+};
+
 // src/kernel/rename-log.ts
 var RENAME_LOG_SIZE = 4096;
 function within8(path, root) {
@@ -25307,6 +25408,18 @@ var PackageLocks = class {
     const names2 = roots.map((root) => replacingLock(this.metadata, root));
     return shared(this.locks, names2, run2, false);
   }
+  holding(root) {
+    const { locks } = this;
+    if (!locks) return Promise.resolve(() => {
+    });
+    const { promise: held, resolve: release } = Promise.withResolvers();
+    return new Promise((granted2, failed3) => {
+      locks.request(replacingLock(this.metadata, root), { mode: "exclusive" }, () => {
+        granted2(() => release());
+        return held;
+      }).catch(failed3);
+    });
+  }
 };
 
 // src/kernel/settling.ts
@@ -27242,15 +27355,15 @@ var OpfsFs = class {
     const hooks = {};
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
     const copying = sourceStat.isDirectory && !movable(source.handle);
-    const staged = resolvePath(parent.path, staging);
+    const staged2 = resolvePath(parent.path, staging);
     const place = async () => {
       this.forget(destination);
       const copies = /* @__PURE__ */ new Map();
       const root = { ino: inodeOf(source.path), ...moving };
       const owned4 = lock ? { lock } : {};
       hooks.notify?.();
-      const first = copying ? await this.intend({ from: source.path, to: staged, root, ...owned4 }) : void 0;
-      const second = copying && swap ? await this.intend({ from: staged, to: destination, replace: true, root, ...owned4 }) : void 0;
+      const first = copying ? await this.intend({ from: source.path, to: staged2, root, ...owned4 }) : void 0;
+      const second = copying && swap ? await this.intend({ from: staged2, to: destination, replace: true, root, ...owned4 }) : void 0;
       await hooks.started?.().catch(async (err) => {
         for (const intent of [first, second]) {
           if (intent) await this.meta.update(intent, () => void 0);
@@ -27261,11 +27374,11 @@ var OpfsFs = class {
         targetStat !== null,
         () => this.place(source.handle, dir, staging, copies)
       ).catch(async (err) => {
-        if (first) await this.rollBack(staged, source.path, [first, second]);
+        if (first) await this.rollBack(staged2, source.path, [first, second]);
         throw err;
       });
       if (swap) await this.rm(destination, { recursive: true });
-      if (second) await this.intend({ from: staged, to: destination, root, ...owned4 }, second);
+      if (second) await this.intend({ from: staged2, to: destination, root, ...owned4 }, second);
       await this.meta.move(source.path, destination, carry, left);
       this.movePending(source.path, destination);
       if (!moved2) {
@@ -29955,15 +30068,15 @@ var UserDb = class {
         (r) => r !== row && this.fs.resolvePath("/", r.home) === home
       );
       const removeHome = !options.keepHome && !shared2 && HOME_DIR.test(home) && await this.fs.exists(home);
-      const staged = `/home/.${name2}.removed-${Date.now()}`;
+      const staged2 = `/home/.${name2}.removed-${Date.now()}`;
       await this.commit(
         formatPasswd(passwd.filter((r) => r !== row)),
         formatGroup(keptGroups),
-        removeHome ? () => this.fs.rename(home, staged) : void 0
+        removeHome ? () => this.fs.rename(home, staged2) : void 0
       );
       this.umasks.delete(name2);
       if (removeHome)
-        await this.fs.rm(staged, { recursive: true, force: true }).catch(() => void 0);
+        await this.fs.rm(staged2, { recursive: true, force: true }).catch(() => void 0);
       return true;
     });
   }
@@ -30700,6 +30813,11 @@ var Launcher = class {
   jobs = new JobTable();
   locks;
   packageLocks;
+  swaps = new PackageSwaps(
+    (path) => this.packageRootIs(path),
+    (root) => this.packageLocks.holding(root),
+    () => this.resetCatalogs()
+  );
   fifos = new FifoTable();
   memories;
   sems = new SemTable();
@@ -30990,7 +31108,7 @@ var Launcher = class {
   commands(scope = "") {
     let found = this.catalogs.get(scope);
     if (!found) {
-      found = this.trustedAppended().then(async (appended2) => {
+      found = this.swaps.settled().then(() => this.trustedAppended()).then(async (appended2) => {
         const tiers = await this.tiers(scope, appended2);
         const refused3 = [];
         const commands = await scanCommands(
@@ -31835,6 +31953,13 @@ var Launcher = class {
     if (readsEtcHostname(program)) setOrDrop(env, "HOSTNAME", own);
     return { planned, env, program, exeId };
   }
+  packageRootIs(path) {
+    const at = normalizePath(path);
+    const within10 = `${at}/`;
+    const roots = [this.modulesDir, ...this.appended];
+    const root = PACKAGE_ROOT.exec(within10)?.[1] ?? packageRootOf(within10, roots);
+    return root === at;
+  }
   packageRoots(planned) {
     const packages2 = [this.modulesDir, ...this.appended];
     const roots = /* @__PURE__ */ new Set();
@@ -32020,6 +32145,7 @@ var Launcher = class {
         opfsOps: this.rootFs.opfsOps?.() ?? 0,
         cwdChecks: this.cwds.checks,
         renameAcks: this.rootFs.renameWaits?.(),
+        swaps: this.swaps.counts(),
         staleFds: staleFdCount(),
         fileIds: this.rootFs.fileIdWrites?.() ?? 0,
         holds: this.rootFs.holdCounts?.()
@@ -32276,6 +32402,7 @@ var Launcher = class {
   spawner(ppid, report) {
     return async (req, fds, grant) => {
       const booked = this.takeTicket(req);
+      await this.swaps.settled();
       if (grant && !await this.grantedCwd(grant.caller, req.cwd)) {
         await fds.closeAll();
         throw new SpawnError("EACCES");
@@ -33188,10 +33315,12 @@ var Launcher = class {
     nodes.changed = (path) => this.changes.publish(path);
     nodes.movedAway = (from, to) => this.moved(from, to, nodes);
     nodes.dirtied = (delta) => this.changes.dirtied(delta);
-    return unlinked.wrap(keepingOpen(fs, nodes, (path) => this.changes.publish(path)));
+    const kept = keepingOpen(fs, nodes, (path) => this.changes.publish(path));
+    return this.swaps.wrap(unlinked.wrap(kept));
   }
   async starting(argv, dir, account, tags, base) {
     const tag = tags?.[0];
+    await this.swaps.settled();
     this.resetCatalogs();
     const scope = account.uid === 0 ? "" : pnpmHomeOf(account, this.pnpmHome);
     const start2 = dir ?? "/";
@@ -33365,7 +33494,7 @@ function sendableClose(code) {
 function blockedReason(url, e) {
   const name2 = e?.name;
   if (name2 === "SecurityError" && url.startsWith("ws:")) {
-    return `${url}: ws:// is blocked from an https page; use wss:// or slicc-node`;
+    return `${url}: ws:// is blocked from an https page; use wss://, or link a slicc CLI (npx sliccy@next)`;
   }
   return `${url}: ${e instanceof Error ? e.message : String(e)}`;
 }