@ai-ecoverse/slicc-kernel 1.124.1 → 1.124.3

package/dist/node.js

@@ -4112,6 +4112,8 @@ var ProtectedFs = class {
 // src/fs/remote.ts
 var ANNOUNCE_WAIT_MS = 500;
 var PRUNE_EVERY_MS = 3e4;
+var MOURN_TRIES = 5;
+var MOURN_RETRY_MS = 100;
 function lockManager() {
   return globalThis.navigator?.locks;
 }
@@ -4120,6 +4122,7 @@ var RemoteWatch = class {
   name;
   tab = crypto.randomUUID();
   peers = /* @__PURE__ */ new Set();
+  mourned = /* @__PURE__ */ new Set();
   others = /* @__PURE__ */ new Map();
   union = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
@@ -4188,8 +4191,7 @@ var RemoteWatch = class {
   receive(data) {
     if (data.hello !== void 0) this.greeted(data.hello);
     if (data.here !== void 0 && data.to === this.tab) {
-      this.peers.add(data.here);
-      this.recount();
+      this.arrived(data.here);
       this.met?.();
     }
     if (data.tab !== void 0 && data.paths !== void 0) this.announced(data);
@@ -4198,9 +4200,36 @@ var RemoteWatch = class {
     }
     if (data.changed !== void 0) this.emit({ paths: data.changed, trees: [] });
   }
-  greeted(peer) {
+  arrived(peer) {
     this.peers.add(peer);
     this.recount();
+    void this.mourn(peer);
+  }
+  async mourn(peer, tries = MOURN_TRIES) {
+    if (!this.locks || this.mourned.has(peer)) return;
+    this.mourned.add(peer);
+    const name2 = this.lockOf(peer);
+    const { held = [], pending = [] } = await this.locks.query();
+    if (![...held, ...pending].some((lock) => lock.name === name2)) {
+      this.mourned.delete(peer);
+      if (tries > 1 && this.peers.has(peer)) {
+        setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
+      }
+      return;
+    }
+    void this.locks.request(name2, async () => {
+      this.mourned.delete(peer);
+      this.others.delete(peer);
+      this.peers.delete(peer);
+      this.rebuild();
+      this.recount();
+      for (const wait2 of this.waiting.values()) {
+        if (wait2.left.delete(peer) && wait2.left.size === 0) wait2.done();
+      }
+    });
+  }
+  greeted(peer) {
+    this.arrived(peer);
     const answer = () => {
       this.channel.postMessage({ here: this.tab, to: peer });
       if (this.mine.length > 0) void this.announce(this.mine);
@@ -4210,8 +4239,7 @@ var RemoteWatch = class {
   }
   announced({ tab, paths, seq: seq2 }) {
     const from = tab;
-    this.peers.add(from);
-    this.recount();
+    this.arrived(from);
     if (paths.length > 0) this.others.set(from, paths);
     else this.others.delete(from);
     this.rebuild();
@@ -4819,7 +4847,8 @@ var OpfsFs = class {
   async linkAlong(path) {
     for (const entry of await this.meta.get(prefixes(path))) {
       if (entry?.link === void 0) continue;
-      if (!await this.real(entry.path) && await this.real(parentOf4(entry.path))) return entry;
+      if (entry.path !== path && await this.real(entry.path)) continue;
+      if (await this.real(parentOf4(entry.path))) return entry;
     }
     return void 0;
   }
@@ -6541,7 +6570,7 @@ var CdpFacade = class {
     for (const conn of this.connections) conn.close();
   }
   async acceptLoop() {
-    const served = /* @__PURE__ */ new Set();
+    const served2 = /* @__PURE__ */ new Set();
     for (; ; ) {
       let conn;
       try {
@@ -6549,10 +6578,10 @@ var CdpFacade = class {
       } catch {
         break;
       }
-      const done4 = this.serve(conn).finally(() => served.delete(done4));
-      served.add(done4);
+      const done4 = this.serve(conn).finally(() => served2.delete(done4));
+      served2.add(done4);
     }
-    await Promise.allSettled([...served]);
+    await Promise.allSettled([...served2]);
   }
   async serve(conn) {
     this.connections.add(conn);
@@ -6944,7 +6973,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.124.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.124.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
@@ -8359,7 +8388,7 @@ var RealmProxy = class {
     for (const conn of this.connections) conn.close();
   }
   async acceptLoop() {
-    const served = /* @__PURE__ */ new Set();
+    const served2 = /* @__PURE__ */ new Set();
     try {
       for (; ; ) {
         await this.slots.acquire(1, this.stop.signal);
@@ -8372,13 +8401,13 @@ var RealmProxy = class {
         }
         const done4 = this.serve(conn).finally(() => {
           this.slots.release(1);
-          served.delete(done4);
+          served2.delete(done4);
         });
-        served.add(done4);
+        served2.add(done4);
       }
     } catch {
     }
-    await Promise.allSettled([...served]);
+    await Promise.allSettled([...served2]);
   }
   async serve(conn) {
     this.connections.add(conn);
@@ -12110,7 +12139,12 @@ var IDENTITY_OPS = /* @__PURE__ */ new Set([
   "chown",
   "lchown"
 ]);
+var served = 0;
+function servedFsCalls() {
+  return served;
+}
 async function dispatchSyncFs(req) {
+  served++;
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
   if (!req.identity || !IDENTITY_OPS.has(req.op)) return dispatchOne(entry, req);
@@ -12816,7 +12850,11 @@ var SYS_TREE = {
     osrelease: `${OS_RELEASE}
 `,
     ostype: "Linux\n",
-    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0}
+    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0} ${listing.wasm?.source ?? "none"}
+`,
+    slicc_shared_root: (listing) => `${listing.peers ?? 0}
+`,
+    slicc_fs_calls: (listing) => `${listing.fsCalls ?? 0}
 `
   }
 };
@@ -21863,37 +21901,65 @@ var SettlingChildren = class {
 
 // src/kernel/wasm-memories.ts
 var DEFAULT_CEILING = 112;
+var CEILING_FLOOR = 16;
 var IDLE_MS = 1e4;
 var MARGIN = 16;
+var DECAY_MS = 6e4;
+var DECAY_STEP = 8;
 var WasmMemories = class {
   live = 0;
-  ceiling;
+  learned;
   waiters = /* @__PURE__ */ new Set();
+  base;
   idleMs;
-  constructor(ceiling, idleMs = IDLE_MS) {
-    this.ceiling = ceiling;
+  now;
+  constructor(ceiling, idleMs = IDLE_MS, now = Date.now) {
+    this.base = ceiling;
     this.idleMs = idleMs;
+    this.now = now;
+  }
+  ceiling() {
+    const learned = this.learned;
+    if (!learned) return this.base;
+    const steps = Math.floor((this.now() - learned.at) / DECAY_MS);
+    const raised = learned.ceiling + steps * DECAY_STEP;
+    if (raised < (this.base ?? DEFAULT_CEILING)) return raised;
+    this.learned = void 0;
+    return this.base;
   }
   count() {
-    return { live: this.live, ceiling: this.ceiling ?? 0 };
+    const ceiling = this.ceiling();
+    const source = this.learned ? "learned" : ceiling === void 0 ? "none" : "default";
+    return { live: this.live, ceiling: ceiling ?? 0, source };
   }
   ended() {
     this.live = Math.max(0, this.live - 1);
     this.progress();
   }
   learn() {
-    this.ceiling = Math.max(1, this.live - 1);
+    const top = this.base ?? DEFAULT_CEILING;
+    this.learned = {
+      ceiling: Math.min(top, Math.max(CEILING_FLOOR, this.live - 1)),
+      at: this.now()
+    };
   }
   near() {
-    return this.ceiling !== void 0 && this.live + MARGIN >= this.ceiling;
+    const ceiling = this.ceiling();
+    return ceiling !== void 0 && this.live + MARGIN >= ceiling;
   }
   async admit() {
-    while (this.ceiling !== void 0 && this.live >= this.ceiling) {
+    for (let ceiling = this.ceiling(); ceiling !== void 0 && this.live >= ceiling; ) {
       if (!await this.changed()) throw new SpawnError("EAGAIN");
+      ceiling = this.ceiling();
     }
     this.live += 1;
     this.progress();
   }
+  async refused() {
+    const ceiling = this.ceiling();
+    if (ceiling === void 0 || this.live >= ceiling) return;
+    if (!await this.changed()) throw new SpawnError("EAGAIN");
+  }
   progress() {
     const waiters = [...this.waiters];
     this.waiters.clear();
@@ -23092,7 +23158,7 @@ async function openHostfs(spec, connect2, timing = {}) {
     ...active?.capabilities.ranges === true ? { ranges: true } : {},
     ...active ? { maxIo: Math.min(active.maxIo, HOSTFS_IO) } : {}
   });
-  const served = serveFilesystem(
+  const served2 = serveFilesystem(
     port2,
     { ...slot2.handlers, mount: ranged2 },
     {
@@ -23109,12 +23175,12 @@ async function openHostfs(spec, connect2, timing = {}) {
       up(client) {
         active = timed(client, timing.callMs ?? HOSTFS_CALL_MS);
         slot2.insert(client, handlers);
-        served.invalidate(true);
+        served2.invalidate(true);
       },
-      event: (event) => served.invalidate(invalidation(event)),
+      event: (event) => served2.invalidate(invalidation(event)),
       down() {
         slot2.eject();
-        served.invalidate(true);
+        served2.invalidate(true);
       },
       ...timing
     },
@@ -25222,6 +25288,10 @@ var Launcher = class {
         return handle;
       }
       await handle.exited;
+      await this.memories.refused().catch(async (err) => {
+        await fds.closeAll();
+        throw err;
+      });
     }
   }
   start(req) {
@@ -25287,7 +25357,9 @@ var Launcher = class {
         processes: this.list(this.credOf(pid)),
         load: this.loadAverage(),
         cpu: this.cpuTotal(),
-        wasm: this.memories.count()
+        wasm: this.memories.count(),
+        peers: Number(this.locks.shared?.() === true),
+        fsCalls: servedFsCalls()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -25781,7 +25853,7 @@ var Launcher = class {
     const worker = this.createDriverWorker();
     const driver = new MessageChannel();
     const client = new MessageChannel();
-    const served = serveClient(client.port1, {
+    const served2 = serveClient(client.port1, {
       launcher: async () => this,
       scope: "transport"
     });
@@ -25793,7 +25865,7 @@ var Launcher = class {
       port: driver.port1,
       dispose: () => {
         worker.terminate();
-        served.detach();
+        served2.detach();
         driver.port1.close();
       },
       onCrash: (listener) => worker.addEventListener("error", (event) => {
@@ -25807,12 +25879,12 @@ var Launcher = class {
     const ask = (handle) => this.onMountPending?.({ target, source, ...handle ? { handle } : {} });
     const { port1, port2 } = new MessageChannel();
     const medium = removableMedium((handle) => {
-      served.invalidate(true);
+      served2.invalidate(true);
       ask(handle);
     });
-    const served = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
+    const served2 = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
     const id2 = source.slice("fsa:".length);
-    this.removable.set(target, { id: id2, medium, served });
+    this.removable.set(target, { id: id2, medium, served: served2 });
     const stored = this.inserted.get(id2) ?? await this.media.get(id2);
     if (stored && await granted(stored)) medium.insert(stored);
     else ask(stored);
@@ -27871,14 +27943,14 @@ async function createNodeKernel(options = {}) {
         throw fsError("ENOENT", `no user ${String(user)}`);
       }
       const { port1, port2 } = new MessageChannel2();
-      const served = serveClient(port1, {
+      const served2 = serveClient(port1, {
         launcher: async () => launcher,
         signal: signalNumber,
         ...user !== void 0 ? { user } : {},
         ...tag !== void 0 ? { tag } : {}
       });
-      clients.add(served);
-      void served.closed.then(() => clients.delete(served));
+      clients.add(served2);
+      void served2.closed.then(() => clients.delete(served2));
       return port2;
     },
     terminate() {