@ai-ecoverse/slicc-kernel 1.143.1 → 1.143.2

package/README.md

@@ -375,7 +375,7 @@ The module's default export (or its `main` export) is called with a context and
     - `'change'`: an existing entry's data or metadata changed (a write, `truncate`, `chmod`, `chown`, `utimes`). A write that creates a file gives `'rename'` and then `'change'`, as on Linux.
     - `filename` is the entry's name relative to the watched directory (`sub/a.txt` when recursive), or the file's basename for a file watch.
   - **Overflow:** a watch holds 1,000 events between reads. Beyond that, the rest are dropped, and `{ overflow: true }` follows the ones kept.
-  - **The watched path itself:** when it is removed or renamed away (or an ancestor is), the watch gets one `'rename'` with its own name, then `{ ended: true }`, and ends. `close()` is safe at any time and idempotent, and nothing is delivered after it returns.
+  - **The watched path itself:** like inotify, a watch follows the file or directory it was opened on, not its name. When a directory above it is renamed, the watch stays on the moved path with no event, and later events keep the name it was opened with. When the path itself is renamed, the watch gets one `{ type: 'rename', filename, moved: true }` and stays on the new path. Only a removal ends it: `rm` of the path or a directory above it, or a rename of something else over it gives one `'rename'` with its own name, then `{ ended: true }`. Renames are followed as this kernel makes them ([#1356](https://github.com/ai-ecoverse/slicc-kernel/issues/1356)). `close()` is safe at any time and idempotent, and nothing is delivered after it returns.
   - **Errors at watch time:** a path the program may not read (under `users`) is `EACCES`, and one that doesn't exist is `ENOENT`. Permission is checked first, so a path under a directory the program can't search is `EACCES` whether or not it exists. A process holds at most 8,192 watches; past that, `ENOSPC`.
   - **Permissions per event:** under `users`, a program only hears about paths it may reach. An event about `P` below the watched directory is delivered only if the program's user can search every directory down to `P`'s parent and read that parent, as Node's recursive watch would need in order to add a watch there. The check runs when the program takes the events, so another user's `0700` directory stays silent until it's opened up. A consequence is that events inside a directory that is gone by the time the program takes them are dropped: after `rm -r sub` the program sees `rename sub` but not `sub/a`. A watcher should rescan on a directory's `rename`, as Node users do anyway.
   - **Who counts as a writer:** every process in the kernel, the embedder (`kernel.writeFile` and the like) and the mounts that report changes. A `hostfs` change from the host comes as `'change'`, since the host doesn't say which kind it was.
@@ -1292,7 +1292,7 @@ The tools in `tools/cert-review/`:
   - and record, which re-hashes the candidate's artifact against the pack job's sha256.
 - **The verdict** goes into the commit status on the pull request's head and a comment on the pull request. Certified is green. A FAIL is red with the line, and the pull request needs a fix. **INCOMPLETE** (a job that didn't succeed, no verdict, a suite without results) is red with `re-run the failed jobs`, never a silent pass. Main moving on after a review doesn't trigger another one; a push does.
 - **Merge groups only look up.** On `merge_group`, the job lists the group's pull requests (its merge commits) and requires, for each one, a green status on the head being merged, or no behaviour change. Otherwise it's red, naming the pull request. Then it adds the group's downstream verdict. The group's `ci / test` covers the combined tree.
-- **Downstream, once per merge group:** the `merge group pack` job packs the group's tree with `main`'s tools (`x.y.z-group.<run>`), and `downstream bios canary` calls slicc-bios's `canary.yml` at a pinned full sha (`fcaa9a23…`, never a tag) with that tarball, bound by artifact id, digest and sha256, on the `sweep`, `guard-prompt`, `guard-lagging`, `k4-upgrade`, `k4-agent-modes` and `link-serve` shards, each run once, on the runner the `canary runner` job picks: `.github/runner.mjs`'s `decide()` from `main`, as `ci.yml` uses it, gives `vars.CERT_CANARY_RUNNER` only to a merge group whose entries are all same-repo PRs, and `ubuntu-latest` otherwise, without the variable, or if the decider fails (bios honours a runner only for merge groups and pushes to main in ai-ecoverse, so rolling back is unsetting the variable). The verdict line names the shards, or their count past 32 characters (`6 shards`), so a status description (140 characters) keeps the reason. `downstream.mjs` judges its result (`downstreamOf` in `lib.mjs`), and the lookup requires it. The `merge group` job reads that result as `result.json` from the canary's own artifact, downloaded by the call's `artifact-id` with `digest-mismatch: error`, not from the `result` output: that output can be up to 512 KB, and one environment variable holds 128 KB, so passing it that way stopped the step from starting at all (`Argument list too long`, runs 39166647175 and 39168823799). A missing or unreadable artifact leaves no result, so the group is INCOMPLETE:
+- **Downstream, once per merge group:** the `merge group pack` job packs the group's tree with `main`'s tools (`x.y.z-group.<run>`), and `downstream bios canary` calls slicc-bios's `canary.yml` at a pinned full sha (`42cdf3a8…`, never a tag) with that tarball, bound by artifact id, digest and sha256, on the `sweep`, `guard-prompt`, `guard-lagging`, `k4-upgrade`, `k4-agent-modes` and `link-serve` shards, each run once, on the runner the `canary runner` job picks: `.github/runner.mjs`'s `decide()` from `main`, as `ci.yml` uses it, gives `vars.CERT_CANARY_RUNNER` only to a merge group whose entries are all same-repo PRs, and `ubuntu-latest` otherwise, without the variable, or if the decider fails (bios honours a runner only for merge groups and pushes to main in ai-ecoverse, so rolling back is unsetting the variable). The verdict line names the shards, or their count past 32 characters (`6 shards`), so a status description (140 characters) keeps the reason. `downstream.mjs` judges its result (`downstreamOf` in `lib.mjs`), and the lookup requires it. The `merge group` job reads that result as `result.json` from the canary's own artifact, downloaded by the call's `artifact-id` with `digest-mismatch: error`, not from the `result` output: that output can be up to 512 KB, and one environment variable holds 128 KB, so passing it that way stopped the step from starting at all (`Argument list too long`, runs 39166647175 and 39168823799). A missing or unreadable artifact leaves no result, so the group is INCOMPLETE:
   - **PASS:** the candidate passes, `downstream: PASS bios … N pass`;
   - **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;

package/dist/kernel-worker.js

@@ -7598,7 +7598,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.143.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.143.2" : "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
@@ -10509,7 +10509,7 @@ function route(watch, type, path) {
 }
 function routed(watch, root, type, path) {
   if (path === root || type === "rename" && root !== "/" && under3(root, path)) {
-    noted(watch, { type, filename: baseOf3(root) });
+    noted(watch, { type, filename: watch.names.get(root) ?? baseOf3(root) });
     if (type === "rename") noted(watch, { ended: true });
     return true;
   }
@@ -10519,6 +10519,11 @@ function routed(watch, root, type, path) {
   } else return false;
   return true;
 }
+function remapped(root, from, to) {
+  if (root === from) return to;
+  if (from !== "/" && root.startsWith(`${from}/`)) return to + root.slice(from.length);
+  return void 0;
+}
 var FsWatchers = class {
   watchers = /* @__PURE__ */ new Set();
   typed = /* @__PURE__ */ new Set();
@@ -10553,6 +10558,7 @@ var FsWatchers = class {
     const other = alias === void 0 ? main : normalizePath(alias);
     const watch = {
       roots: other === main ? [main] : [main, other],
+      names: /* @__PURE__ */ new Map(),
       recursive,
       notes: [],
       overflowed: false,
@@ -10602,6 +10608,35 @@ var FsWatchers = class {
       for (const watch of [...this.typed]) route(watch, type, at);
     }
   }
+  moved(from, to) {
+    const source = normalizePath(from);
+    const target = normalizePath(to);
+    const followed2 = /* @__PURE__ */ new Set();
+    for (const watch of this.typed) {
+      const [main] = watch.roots;
+      const roots = watch.roots.map((root) => remapped(root, source, target) ?? root);
+      if (roots.every((root, i) => root === watch.roots[i])) continue;
+      followed2.add(watch);
+      const names2 = /* @__PURE__ */ new Map();
+      watch.roots.forEach((root, i) => {
+        names2.set(roots[i], watch.names.get(root) ?? baseOf3(root));
+      });
+      watch.names = names2;
+      watch.roots = [...new Set(roots)];
+      if (main === source) {
+        noted(watch, { type: "rename", filename: names2.get(target), moved: true });
+      }
+    }
+    return followed2;
+  }
+  renamed(from, to) {
+    const followed2 = this.moved(from, to);
+    if (this.typed.size === 0) return;
+    for (const path of [from, to]) {
+      const at = normalizePath(path);
+      for (const watch of [...this.typed]) if (!followed2.has(watch)) route(watch, "rename", at);
+    }
+  }
   changed(...paths) {
     this.report(paths);
     this.emit("change", paths);
@@ -10705,7 +10740,16 @@ var FsWatchers = class {
         }
       },
       rm: reshaping(after(fs.rm.bind(fs), (path) => [path], "rename")),
-      rename: reshaping(after(fs.rename.bind(fs), (from, to) => [from, to], "rename")),
+      rename: reshaping(async (from, to) => {
+        let done5 = false;
+        try {
+          await fs.rename(from, to);
+          done5 = true;
+        } finally {
+          this.report([from, to]);
+          if (done5) this.renamed(from, to);
+        }
+      }),
       link: reshaping(
         after(
           (from, to, follow2) => fs.link(from, to, follow2),