@ai-ecoverse/slicc-kernel 1.122.3 → 1.123.1

package/dist/node.js

@@ -3568,7 +3568,7 @@ var MemoryMeta = class {
     if (entry) this.entries.set(path, entry);
     else this.entries.delete(path);
   }
-  async move(from, to, root) {
+  async move(from, to, root, left) {
     await this.remove([to]);
     const carried = this.entries.subtree(from).map((path) => this.entries.get(path));
     for (const entry of carried) this.entries.delete(entry.path);
@@ -3577,6 +3577,7 @@ var MemoryMeta = class {
       if (path !== to) this.entries.set(path, moved(entry, path));
     }
     this.entries.set(to, moved(root(carried.find((entry) => entry.path === from)), to));
+    if (left) this.entries.set(from, left);
   }
   async remove(paths) {
     for (const path of paths) this.entries.deleteTree(path);
@@ -4228,6 +4229,14 @@ function sidecar(meta) {
     });
   return ops;
 }
+function occupied(entry) {
+  if (!entry?.vacated) return entry ?? {};
+  const { vacated: _, ...kept } = entry;
+  return kept;
+}
+function vacatedAt(path) {
+  return { path, ino: inodeOf(`${path}\0${crypto.randomUUID()}`), vacated: true };
+}
 function missing2(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
@@ -4458,7 +4467,7 @@ var OpfsFs = class {
     const kind = directory ? void 0 : owner?.socket ? "socket" : owner?.fifo ? "fifo" : void 0;
     const unique = kind === "fifo" ? { ino: inodeOf(`${path}\0${crypto.randomUUID()}`) } : {};
     const fields = kind ? { ...owned4, ...unique, [kind]: true } : owned4;
-    if (fields) await this.meta.update(path, (entry) => ({ ...entry, path, ...fields }));
+    if (fields) await this.meta.update(path, (entry) => ({ ...occupied(entry), path, ...fields }));
   }
   guarded = [];
   protect(prefixes2, versions = false) {
@@ -5170,8 +5179,9 @@ var OpfsFs = class {
     await this.locked(physical, async () => {
       if (await this.handleExists(dir, name2)) throw fsError("EEXIST", path);
       const freshMeta = this.meta.fresh ? await this.meta.fresh([path]) : await this.meta.get([path]);
-      if (freshMeta[0]?.link !== void 0) throw fsError("EEXIST", path);
-      if (freshMeta[0] !== void 0) await this.meta.remove([path]);
+      const found = freshMeta[0];
+      if (found?.link !== void 0) throw fsError("EEXIST", path);
+      if (found !== void 0 && !found.vacated) await this.meta.remove([path]);
       this.forget(physical);
       this.refuse(physical);
       await dir.getDirectoryHandle(name2, { create: true });
@@ -5191,8 +5201,9 @@ var OpfsFs = class {
     await this.locked(physical, async () => {
       if (await this.handleExists(dir, name2)) throw fsError("EEXIST", path);
       const freshMeta = this.meta.fresh ? await this.meta.fresh([path]) : await this.meta.get([path]);
-      if (freshMeta[0]?.link !== void 0) throw fsError("EEXIST", path);
-      if (freshMeta[0] !== void 0) await this.meta.remove([path]);
+      const found = freshMeta[0];
+      if (found?.link !== void 0) throw fsError("EEXIST", path);
+      if (found !== void 0 && !found.vacated) await this.meta.remove([path]);
       this.forget(physical);
       this.refuse(physical);
       await dir.getFileHandle(name2, { create: true });
@@ -5296,14 +5307,15 @@ var OpfsFs = class {
     const moving = await this.movedOwner(source);
     const carry = (entry) => ({
       ino: inodeOf(source.path),
-      ...entry,
+      ...occupied(entry),
       ...moving,
       path: destination,
       ctimeMs: now
     });
+    const left = vacatedAt(source.path);
     if (source.link) {
       if (target?.handle) await this.rm(destination);
-      await this.meta.move(source.path, destination, carry);
+      await this.meta.move(source.path, destination, carry, left);
       this.touch(Date.now(), parentOf4(source.path), parent.path);
       return;
     }
@@ -5318,9 +5330,12 @@ var OpfsFs = class {
       () => this.place(source.handle, dir, staging)
     );
     if (swap) await this.rm(destination, { recursive: true });
-    await this.meta.move(source.path, destination, carry);
+    await this.meta.move(source.path, destination, carry, left);
     this.movePending(source.path, destination);
-    if (!moved2) await this.rm(source.path, { recursive: true });
+    if (!moved2) {
+      await this.rm(source.path, { recursive: true });
+      await this.meta.update(source.path, () => left);
+    }
     let copied = !moved2;
     if (swap) {
       const staged = await dir.getDirectoryHandle(staging);
@@ -5405,11 +5420,11 @@ var OpfsFs = class {
     const fields = await this.newFields(at, owner && { uid: owner.uid, gid: owner.gid }, false);
     await this.entering(
       at,
-      () => this.meta.update(at, () => ({
+      () => this.meta.update(at, (entry) => ({
         path: at,
         link: target,
         dir: parent.path,
-        ino: inodeOf(at),
+        ino: entry?.vacated && entry.ino !== void 0 ? entry.ino : inodeOf(at),
         mtimeMs: now,
         ctimeMs: now,
         ...fields
@@ -5477,7 +5492,10 @@ var OpfsFs = class {
   }
   async reconcile() {
     let removed = 0;
-    for (const entry of await this.meta.all()) {
+    const entries = await this.meta.all();
+    const carried = new Set(entries.filter((e) => !e.vacated).map((e) => e.ino));
+    for (const entry of entries) {
+      if (entry.vacated && carried.has(inodeOf(entry.path))) continue;
       const real = await this.real(entry.path);
       const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf4(entry.path));
       if (!stale) continue;
@@ -6779,7 +6797,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.122.3" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.123.1" : "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
@@ -12647,17 +12665,28 @@ var FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
 var PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
 var SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime", "version"];
 var SYS_TREE = {
-  kernel: { osrelease: `${OS_RELEASE}
-`, ostype: "Linux\n" }
+  kernel: {
+    osrelease: `${OS_RELEASE}
+`,
+    ostype: "Linux\n",
+    slicc_wasm_memories: (listing) => `${listing.wasm?.live ?? 0} ${listing.wasm?.ceiling ?? 0}
+`
+  }
 };
+function isSysFile(at) {
+  return typeof at === "string" || typeof at === "function";
+}
 function sysEntry(parts2) {
   let at = SYS_TREE;
   for (const part of parts2) {
-    if (typeof at !== "object" || !Object.hasOwn(at, part)) return void 0;
+    if (isSysFile(at) || !Object.hasOwn(at, part)) return void 0;
     at = at[part];
   }
   return at;
 }
+function sysText(file, listing) {
+  return typeof file === "string" ? file : file(listing());
+}
 function commOf(info) {
   const name2 = info.argv[0] ?? "";
   return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
@@ -12893,7 +12922,9 @@ var ProcTree = class {
     }
     if (top === "sys") {
       const entry = sysEntry(parts2.slice(1));
-      if (typeof entry === "string") return { kind: "file", content: () => entry };
+      if (typeof entry === "string" || typeof entry === "function") {
+        return { kind: "file", content: () => sysText(entry, () => this.listing()) };
+      }
       return entry && { kind: "dir", names: () => Object.keys(entry) };
     }
     if (top === "self") {
@@ -19192,6 +19223,7 @@ var WasmProcess = class {
 var WASM_PROCESS_INIT = "wasm-process-init";
 var WASM_PROCESS_EXIT = "wasm-process-exit";
 var WASM_PROCESS_ERROR = "wasm-process-error";
+var WASM_PROCESS_READY = "wasm-process-ready";
 var WASM_THREAD_SPAWN = "wasm-thread-spawn";
 var WASM_THREAD_INIT = "wasm-thread-init";
 var WASM_THREAD_EXIT = "wasm-thread-exit";
@@ -19199,6 +19231,8 @@ var WASM_MAX_THREADS = 256;
 
 // src/kernel/host.ts
 var CRASHED = 70;
+var NO_MEMORY = 126;
+var WASM_OOM = /Cannot allocate Wasm memory|WebAssembly\.Memory\(\): could not allocate memory/;
 var KILL_GRACE_MS = 2e3;
 var KILL_HARD_MS = 5e3;
 var descIds = /* @__PURE__ */ new WeakMap();
@@ -19464,7 +19498,22 @@ function threadInit(opts, program, sab, cred, thread, main) {
 function settleExit(exit, settle, code) {
   void exit.catch(() => void 0).then(() => settle(code & 255));
 }
+function readiness(abi) {
+  const ready2 = Promise.withResolvers();
+  if (abi === "js") ready2.resolve(true);
+  return ready2;
+}
+function outOfMemory(opts, data) {
+  if (data?.type !== WASM_PROCESS_ERROR || !WASM_OOM.test(String(data.message))) return false;
+  if (!opts.onOom?.()) {
+    opts.onError?.(
+      `${opts.argv0}: cannot allocate memory for a new process (too many processes at once)`
+    );
+  }
+  return true;
+}
 function spawnWasmProcess(opts) {
+  const { promise: ready2, resolve: started } = readiness(opts.program.abi);
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
   const header4 = new Int32Array(sab, 0, SAB_HEADER_I32);
   const blocked2 = opts.fork?.wasi?.blocked ?? opts.blocked;
@@ -19517,6 +19566,7 @@ function spawnWasmProcess(opts) {
   const finish = (code, sig) => {
     if (done4) return;
     done4 = true;
+    started(true);
     clocks.freeze();
     dying.clear();
     endedBy = sig ?? process2.execTermsig;
@@ -19534,7 +19584,12 @@ function spawnWasmProcess(opts) {
     queueMicrotask(() => finish(...dying.status(code)));
   };
   const handle = (data) => {
-    if (data?.type === WASM_PROCESS_EXIT) {
+    if (data?.type === WASM_PROCESS_READY) {
+      started(true);
+    } else if (outOfMemory(opts, data)) {
+      started(false);
+      finish(NO_MEMORY);
+    } else if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
       if (!dying.ending) opts.onError?.(String(data.message));
@@ -19608,6 +19663,7 @@ function spawnWasmProcess(opts) {
   return {
     pid: opts.pid,
     exited,
+    ready: ready2,
     kill,
     signal,
     termsig: () => endedBy,
@@ -21202,6 +21258,63 @@ var SettlingChildren = class {
   }
 };
 
+// src/kernel/wasm-memories.ts
+var DEFAULT_CEILING = 112;
+var IDLE_MS = 1e4;
+var MARGIN = 16;
+var WasmMemories = class {
+  live = 0;
+  ceiling;
+  waiters = /* @__PURE__ */ new Set();
+  idleMs;
+  constructor(ceiling, idleMs = IDLE_MS) {
+    this.ceiling = ceiling;
+    this.idleMs = idleMs;
+  }
+  count() {
+    return { live: this.live, ceiling: this.ceiling ?? 0 };
+  }
+  ended() {
+    this.live = Math.max(0, this.live - 1);
+    this.progress();
+  }
+  learn() {
+    this.ceiling = Math.max(1, this.live - 1);
+  }
+  near() {
+    return this.ceiling !== void 0 && this.live + MARGIN >= this.ceiling;
+  }
+  async admit() {
+    while (this.ceiling !== void 0 && this.live >= this.ceiling) {
+      if (!await this.changed()) throw new SpawnError("EAGAIN");
+    }
+    this.live += 1;
+    this.progress();
+  }
+  progress() {
+    const waiters = [...this.waiters];
+    this.waiters.clear();
+    for (const wake of waiters) wake();
+  }
+  changed() {
+    return new Promise((resolve2) => {
+      const wake = () => {
+        clearTimeout(timer);
+        resolve2(true);
+      };
+      const timer = setTimeout(() => {
+        this.waiters.delete(wake);
+        resolve2(false);
+      }, this.idleMs);
+      this.waiters.add(wake);
+    });
+  }
+};
+function defaultCeiling() {
+  const node = globalThis.process?.versions?.node;
+  return node === void 0 ? DEFAULT_CEILING : void 0;
+}
+
 // src/mount/driver.ts
 function ownerOf2(req) {
   const owner = {
@@ -23467,6 +23580,9 @@ function withScriptEnv(target, command) {
     ]
   };
 }
+function memoriesOf(given) {
+  return new WasmMemories(given?.ceiling ?? defaultCeiling(), given?.idleMs);
+}
 function childHandle(handle) {
   return {
     pid: handle.pid,
@@ -23538,6 +23654,7 @@ var Launcher = class {
   jobs = new JobTable();
   locks;
   fifos = new FifoTable();
+  memories;
   sems = new SemTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
   ptys = new PtyTable(
@@ -23591,6 +23708,7 @@ var Launcher = class {
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
+    this.memories = memoriesOf(options.wasmMemories);
     this.rootFs = options.fs;
     const peers = options.fs.peers?.();
     this.locks = kernelLocks(options.fs.rootName, peers);
@@ -24421,7 +24539,11 @@ var Launcher = class {
     }
     const done4 = this.heldUrl(program);
     try {
-      const handle = this.start({ ...req, cwd, program, argv0: target.argv0, args, env });
+      const handle = await this.admitted(
+        program.abi !== "js",
+        req.fds,
+        (fds, quietOom) => this.start({ ...req, fds, quietOom, cwd, program, argv0: target.argv0, args, env })
+      );
       void handle.exited.finally(done4);
       return handle;
     } catch (err) {
@@ -24465,6 +24587,39 @@ var Launcher = class {
     if (req.tag !== void 0) this.tags.set(pid, req.tag);
     if (req.links !== void 0) this.links.set(pid, req.links);
   }
+  async admitted(wasm, fds, start2) {
+    if (!wasm) return start2(fds);
+    for (; ; ) {
+      await this.memories.admit().catch(async (err) => {
+        await fds.closeAll();
+        throw err;
+      });
+      const counted3 = (handle2) => {
+        void handle2.exited.finally(() => this.memories.ended());
+        return handle2;
+      };
+      if (!this.memories.near()) {
+        try {
+          return counted3(start2(fds));
+        } catch (err) {
+          this.memories.ended();
+          throw err;
+        }
+      }
+      const forked = fds.fork();
+      const handle = await Promise.resolve().then(() => counted3(start2(forked, true))).catch(async (err) => {
+        this.memories.ended();
+        await forked.closeAll();
+        throw err;
+      });
+      const fit = await (handle.ready ?? true);
+      if (fit) {
+        await fds.closeAll();
+        return handle;
+      }
+      await handle.exited;
+    }
+  }
   start(req) {
     this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
@@ -24515,6 +24670,10 @@ var Launcher = class {
       ...this.prefixes.length > 0 && !stack.writer ? { readonlyAt: (path) => isProtected(this.prefixes, path) } : {},
       createWorker: this.createWorker,
       onError: req.report,
+      onOom: () => {
+        this.memories.learn();
+        return req.quietOom === true;
+      },
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
       kill: (target, sig, info) => this.kill(target, sig, this.credOf(pid), pid, info),
@@ -24523,7 +24682,8 @@ var Launcher = class {
         boot: this.boot,
         processes: this.list(this.credOf(pid)),
         load: this.loadAverage(),
-        cpu: this.cpuTotal()
+        cpu: this.cpuTotal(),
+        wasm: this.memories.count()
       }),
       sudo: (call, signal) => this.sudo(pid, call, signal),
       crontab: (call) => this.crontab(pid, call),
@@ -24860,9 +25020,10 @@ var Launcher = class {
   }
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
-    return async (state, fds) => childHandle(
-      this.start({
+    return async (state, given) => {
+      const fresh2 = (fds, quietOom) => this.start({
         ...image,
+        quietOom,
         cwd: state.cwd ?? parent.cwd,
         fds,
         ppid,
@@ -24873,8 +25034,9 @@ var Launcher = class {
         cred: this.credOf(ppid),
         tag: this.tagOf(ppid),
         links: this.links.get(ppid)
-      })
-    );
+      });
+      return childHandle(await this.admitted(parent.program.abi !== "js", given, fresh2));
+    };
   }
   keySignal(tty, fallback, sig, send) {
     const pgid = this.jobs.tcgetpgrp(tty, fallback);