@ai-ecoverse/slicc-kernel 1.134.0 → 1.134.3

package/README.md

@@ -1096,8 +1096,8 @@ The kernel writes `/etc/passwd` and `/etc/group` when it starts (see [Users](#us
 ### How many processes at once
 
 In a browser every process worker of the page shares one renderer. V8 reserves about 8 GiB of address space for each 32-bit wasm memory, whatever its declared maximum, and its sandbox holds about 1 TiB. So a page runs about 125 wasm processes (or programs that own a wasm memory) at once, counting everything in the renderer (#970). Node has no such ceiling, and neither does Linux. The kernel keeps processes inside that ceiling:
-- **The ceiling:** 112 by default in a browser and none in Node. It's the kernel's count of live wasm processes, with the kernel's other wasm memories in the page left outside it. When an instantiation runs out of memory anyway, the kernel learns the real ceiling at that moment (the live count minus one), and that learned value wins over the default. A learned ceiling is never below 16, since an OOM at a low count means something outside it (another tab in the same renderer) filled the renderer. It's raised by 8 for each minute without another OOM, back to the default.
-- **Admission:** a spawn, fork, exec or `kernel.run` at the ceiling waits for another process to exit. It keeps waiting as long as processes exit or are admitted, and fails with `EAGAIN` only after 10 s with neither. A long `make -j` or `xargs -P` therefore queues, and a pipeline that needs more live processes than the ceiling fails cleanly. bash's own retry on a fork's `EAGAIN` (`fork: retry: Resource temporarily unavailable`) handles the rest.
+- **The ceiling:** 112 by default in a browser and none in Node (`createNodeKernel({ wasmMemories: { ceiling, idleMs } })` sets one in Node; `idleMs`, the quiet spell before `EAGAIN` below, 10 s by default, is there for tests). It's the kernel's count of live wasm processes, with the kernel's other wasm memories in the page left outside it. When an instantiation runs out of memory anyway, the kernel learns the real ceiling at that moment (the live count minus one), and that learned value wins over the default. A learned ceiling is never below 16, since an OOM at a low count means something outside it (another tab in the same renderer) filled the renderer. It's raised by 8 for each minute without another OOM, back to the default.
+- **Admission:** a spawn, fork, exec or `kernel.run` at the ceiling waits for another process to exit. It keeps waiting as long as processes exit, are admitted or finish starting (a process becoming ready counts, so a slow host that is still booting the processes ahead of it doesn't fail the spawn, #1196), and fails with `EAGAIN` only after 10 s with none of these. A long `make -j` or `xargs -P` therefore queues, and a pipeline that needs more live processes than the ceiling fails cleanly. bash's own retry on a fork's `EAGAIN` (`fork: retry: Resource temporarily unavailable`) handles the rest.
 - **Close to the ceiling** (within 16 of it), the kernel waits for each new process to finish instantiating before the spawn returns. If it ran out of memory, the kernel starts it again, quietly, once there's room, so the caller sees no failure.
 - **The rare residual case:** a process that fails to instantiate with nobody waiting on it, which happens only when something outside the count fills the renderer. It ends with status 126 and `<program>: cannot allocate memory for a new process (too many processes at once)` on its stderr, never a JS `RangeError`.
 - **Below a learned ceiling,** a process that still runs out of memory is started again once another process exits, and the spawn fails with `EAGAIN` after 10 s with none.
@@ -1251,7 +1251,7 @@ The tools in `tools/cert-review/`:
   - **FAIL:** a regression, or a failing test (by the counts, even without its rows) is **not certified**, and the group is red;
   - **INCOMPLETE** blocks too: no result, a result from another bios than the pinned one, a missing shard, a shard that exited without a failing test, a refused candidate, 0 tests run, or no test passed;
   - **not judged:** every failing test fails on `main`'s own pins too (`both`), so the canary is broken on `main`, not by this group. That passes with a note, as do `both` rows next to a pass. Either way, `pr notice` opens one issue, `downstream: bios canary failing on main (<bios sha>)`, or comments on the open one, and the next group that passes closes it. Flaky rows are advisory.
-- **`downstream-override`**, next to `cert-review-approved`: a coordinator-only label that waives a downstream FAIL. It is head-bound by the same self-guard (`cert-self-guard` with `approval-label: downstream-override` and every path, dot paths included), so a push drops it. It applies only when **every** pull request in the group carries it on the head being merged: the group reads the guard's receipt and waives only when each member was checked and approved, so a pull request whose paths the guard's globs miss gets no waiver. The group's line then reads `downstream: overridden (downstream-override on the head, by the coordinator) …`, with the failure it waived. It never covers INCOMPLETE. A pull request's own certification line ends `downstream: merge group`, since its downstream verdict comes in the group.
+- **No downstream waiver.** A downstream FAIL or INCOMPLETE in the merge group is not certified; fix the regression or bios's side first (the coordinator-only `downstream-override` label was removed with the 2026-10-19 cert model). A pull request's own certification line ends `downstream: merge group`, since its downstream verdict comes in the group.
 
 Not part of the run yet: the rest of bios's setup (the `rest` shard, the upgrade boot, the sudo rows under `enforce`). More shards plug in through the canary call's `shards`.
 

package/dist/kernel-worker.js

@@ -2378,14 +2378,14 @@ var OpfsFs = class {
     const staged = resolvePath(parent.path, staging);
     const place = async () => {
       this.forget(destination);
-      const timed2 = await this.explicitTimes(source.path);
+      const copies = /* @__PURE__ */ new Map();
       const root = { ino: inodeOf(source.path), ...moving };
       const owned4 = lock ? { lock } : {};
       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 moved2 = await this.replacingTarget(
         targetStat !== null,
-        () => this.place(source.handle, dir, staging)
+        () => this.place(source.handle, dir, staging, copies)
       ).catch(async (err) => {
         if (first) await this.rollBack(staged, source.path, [first, second]);
         throw err;
@@ -2399,15 +2399,13 @@ var OpfsFs = class {
         await this.meta.update(source.path, () => left);
       }
       if (first) await this.meta.update(first, () => void 0);
-      let copied = !moved2;
       if (swap) {
         const hidden = await dir.getDirectoryHandle(staging);
-        const placed = await this.place(hidden, dir, name2);
+        const placed = await this.place(hidden, dir, name2, copies);
         if (!placed) await dir.removeEntry(staging, { recursive: true });
-        copied ||= !placed;
       }
       if (second) await this.meta.update(second, () => void 0);
-      if (copied) await this.restamp(destination, timed2);
+      await this.restamp(destination, copies);
       this.changed(source.path, destination);
       this.touch(Date.now(), parentOf3(source.path), parent.path);
     };
@@ -2570,15 +2568,21 @@ var OpfsFs = class {
     let writable2;
     let handle;
     try {
-      const [made2, existed, at] = await this.fileFor(destination);
-      handle = made2;
-      target = at;
-      if (!existed && !created4) {
-        created4 = true;
-        await this.stampNew(target, options.owner, false);
+      const kept = created4 ? this.files.get(destination) : void 0;
+      if (kept) {
+        if (options.owner?.fifo || options.owner?.socket) throw fsError("ENXIO", to);
+        handle = kept;
+      } else {
+        const [made2, existed, at] = await this.fileFor(destination);
+        handle = made2;
+        target = at;
+        if (!existed && !created4) {
+          created4 = true;
+          await this.stampNew(target, options.owner, false);
+        }
+        const [entry] = await this.meta.get([target]);
+        if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
       }
-      const [entry] = await this.meta.get([target]);
-      if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
       this.wrote(handle);
       writable2 = await handle.createWritable();
       await writable2.write(file);
@@ -2618,22 +2622,17 @@ var OpfsFs = class {
     const handle = await this.handle(path);
     return handle.kind === "file" ? (await this.snapshot(handle)).lastModified : 0;
   }
-  async explicitTimes(path) {
-    const timed2 = [];
-    for (const entry of await this.meta.under(path)) {
-      if (entry.mtimeFor === void 0 || entry.link !== void 0) continue;
-      const current = await this.modified(entry.path).catch(() => void 0);
-      if (current === entry.mtimeFor) timed2.push(entry.path.slice(path.length));
-    }
-    return timed2;
-  }
-  async restamp(path, timed2) {
-    for (const rest2 of timed2) {
-      const mtimeFor = await this.modified(path + rest2);
+  async restamp(path, copies) {
+    if (copies.size === 0) return;
+    const copied = [...copies];
+    const entries = await this.meta.get(copied.map(([rest2]) => path + rest2));
+    for (const [i, [rest2, { before, made: made2 }]] of copied.entries()) {
+      if (entries[i]?.mtimeFor !== before) continue;
+      const mtimeFor = (await this.io(made2.getFile())).lastModified;
       await this.meta.update(path + rest2, (entry) => entry && { ...entry, mtimeFor });
     }
   }
-  async place(handle, dir, name2) {
+  async place(handle, dir, name2, copies) {
     const move = handle.move;
     if (move) this.others++;
     const moved2 = await move?.call(handle, dir, name2).then(
@@ -2643,7 +2642,7 @@ var OpfsFs = class {
     if (moved2) return true;
     const before = this.fileMoves;
     try {
-      await this.copy(handle, dir, name2);
+      await this.copy(handle, dir, name2, copies);
     } catch (err) {
       if (handle.kind === "directory" && this.fileMoves === before) {
         await this.io(dir.removeEntry(name2, { recursive: true }));
@@ -2653,7 +2652,7 @@ var OpfsFs = class {
     return false;
   }
   fileMoves = 0;
-  async copy(handle, dir, name2) {
+  async copy(handle, dir, name2, copies, rest2 = "") {
     if (handle.kind === "file" && movable(handle)) {
       this.others++;
       const moved2 = await handle.move?.(dir, name2).then(
@@ -2668,13 +2667,17 @@ var OpfsFs = class {
     if (handle.kind === "file") {
       const made2 = await this.io(dir.getFileHandle(name2, { create: true }));
       const writable2 = await this.io(made2.createWritable());
-      await writable2.write(await this.io(handle.getFile()));
+      const file = await this.io(handle.getFile());
+      await writable2.write(file);
       await writable2.close();
+      copies?.set(rest2, { before: copies.get(rest2)?.before ?? file.lastModified, made: made2 });
       return;
     }
     const target = await this.io(dir.getDirectoryHandle(name2, { create: true }));
     this.others++;
-    for await (const child of handle.values()) await this.copy(child, target, child.name);
+    for await (const child of handle.values()) {
+      await this.copy(child, target, child.name, copies, `${rest2}/${child.name}`);
+    }
   }
   async symlink(target, path, owner) {
     const parent = await this.locate(parentOf3(path), true);
@@ -7095,7 +7098,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.134.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.134.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
@@ -24766,6 +24769,9 @@ var WasmMemories = class {
     const source = this.learned ? "learned" : ceiling === void 0 ? "none" : "default";
     return { live: this.live, ceiling: ceiling ?? 0, source };
   }
+  started() {
+    this.progress();
+  }
   ended() {
     this.live = Math.max(0, this.live - 1);
     this.progress();
@@ -28082,6 +28088,7 @@ var Launcher = class {
       });
       const counted2 = (handle2) => {
         void handle2.exited.finally(() => this.memories.ended());
+        void Promise.resolve(handle2.ready).then(() => this.memories.started());
         return handle2;
       };
       if (!this.memories.near()) {