@ai-ecoverse/slicc-kernel 1.26.1 → 1.26.2

package/README.md

@@ -120,7 +120,7 @@ const { status, stdout } = await kernel.run(['bash', '-c', 'echo hi'], { cwd: '/
 kernel.terminate();
 ```
 
-`createNodeKernel({ root, modules, env, network, worker, processMounts, fstabRetries, cdp })` takes the options of `createKernel` except `metadata`, and `fstabRetries`, the delays in ms between tries of a failing `/etc/fstab` line (default `[1000, 4000, 16000]`). `root` is an in-memory directory by default (`memoryRoot()` makes another), which keeps each file in 1 MiB chunks, and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal` and `terminate` as above, plus `root`, `writeFile(path, data)` (creating the parent directories) and `readFile(path)` to put files in place and read results. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect()` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
+`createNodeKernel({ root, modules, env, network, worker, processMounts, fstabRetries, cdp, hostfs })` takes the options of `createKernel` except `metadata`, and `fstabRetries`, the delays in ms between tries of a failing `/etc/fstab` line (default `[1000, 4000, 16000]`). `root` is an in-memory directory by default (`memoryRoot()` makes another), which keeps each file in 1 MiB chunks, and POSIX metadata stays in memory. Processes and threads run on `worker_threads`. The kernel has `run`, `openTerminal` and `terminate` as above, plus `root`, `writeFile(path, data)` (creating the parent directories) and `readFile(path)` to put files in place and read results. `nodeTransport()` is `fetchTransport()` with Node's `fetch`, which no CORS binds (`crossOrigin: 'any'`). `connect()` and `attachKernel` work as in the browser: the port is a `worker_threads` `MessagePort`, which a worker thread can attach with, and `terminate()` ends every attached client.
 
 ## Commands
 
@@ -282,7 +282,7 @@ A `hostfs` mount is a folder exported by the local proxy ([slicc-node](https://g
 - **Options:** `ro` mounts read-only, and `maxfile` caps file size as on any mount. There is no other size limit: reads and writes go in `maxIo` pieces (16 MiB unless the proxy says otherwise), so a file of any size the host can hold works. A proxy that advertises `ranges` in its grant (slicc-node 2.4, slicc-swift 1.4) makes the mount ranged, so programs read and write its files in pages and truncate through `setattr` `size`. With an older proxy files go whole, and a truncate on a ranged mount whose proxy was replaced by an older one is done by rewriting the file.
 - **Changes on the host** arrive as invalidations on a watch stream (`POST /api/hostfs/watch`), so an edit made outside shows up on the next access without a remount.
 - **Proxy loss:** when the watch stream ends, or is silent for 45 s, the kernel reconnects once at once. If that fails, the mount is `nomedium`, as with [removable media](#removable-media-fsa): operations fail with `ENOMEDIUM` (`ENODEV` for WASI), and the kernel keeps reconnecting with backoff (1 s to 30 s), so the folder comes back by itself when the proxy does. A mount made while the proxy is down starts as `nomedium`, and so does one whose grant or first watch takes more than 15 s; it comes up by itself when they arrive.
-- **Consistency:** a file that changes on the host while a program reads it fails with `ESTALE`, and the kernel restarts the whole read (up to 3 times) instead of stitching two versions together. On a ranged mount an open file keeps the version it was opened at (its ETag) until it writes: a page fetched after the host changed the file fails the program's read with `ESTALE` instead of mixing versions.
+- **Consistency:** a file that changes on the host while a program reads it fails with `ESTALE`, and the kernel restarts the whole read (up to 3 times) instead of stitching two versions together. On a ranged mount an open file keeps the version it was opened at (its ETag) until it writes, also when it is handed to a child process: a page fetched after the host changed the file fails the program's read with `ESTALE` ("Stale file handle") instead of mixing versions.
 
 ### Mounting from a program
 

package/dist/kernel-worker.js

@@ -5103,6 +5103,9 @@ var MountFs = class {
       truncate: false,
       exclusive: false,
       ...version !== void 0 ? { ifMatch: version } : {}
+    }).catch((err) => {
+      const gone = version !== void 0 && err.code === "ENOENT";
+      throw gone ? errnoError("ESTALE", `${real} is gone from the host`) : err;
     });
     const chunk2 = mount.caps.maxIo ?? DEFAULT_IO;
     const chunks = [];
@@ -6703,6 +6706,7 @@ function within3(path, root) {
 var VfsNode = class {
   data;
   ranged;
+  pin;
   length = 0;
   dirty = false;
   queue = Promise.resolve();
@@ -6714,8 +6718,9 @@ var VfsNode = class {
   fs;
   path;
   orphaned;
-  constructor(fs, path, contents2, orphaned = false, dirty = false) {
+  constructor(fs, path, contents2, orphaned = false, dirty = false, pin) {
     this.fs = fs;
+    this.pin = pin;
     this.path = path;
     this.orphaned = orphaned;
     if (contents2 !== void 0) this.data = new Uint8Array(contents2);
@@ -6739,6 +6744,10 @@ var VfsNode = class {
     if (this.revoked) throw new KernelError("EIO");
     if (this.ranged || this.data) return this.ranged;
     const io = rangedOps(this.fs);
+    if (io && this.pin && !this.orphaned) {
+      this.ranged = new AsyncRangedFile(io, this.path, this.pin.size, this.pin.version);
+      return this.ranged;
+    }
     const st = io && !this.orphaned ? await this.fs.stat?.(this.path).catch(() => void 0) : void 0;
     if (io && st?.ranged) {
       this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0, st.version);
@@ -6878,10 +6887,10 @@ var VfsNodes = class {
   constructor(fs) {
     this.fs = fs;
   }
-  open(path) {
+  open(path, pin) {
     let node = this.byPath.get(path);
     if (!node) {
-      node = new VfsNode(this.fs, path);
+      node = new VfsNode(this.fs, path, void 0, false, false, pin);
       this.byPath.set(path, node);
     }
     node.opens++;
@@ -7002,7 +7011,7 @@ function vfsFile(fs, opts, nodes) {
   const access = opts.flags & O_ACCMODE;
   const readable = access !== O_WRONLY;
   const writable = access === O_WRONLY || access === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true) : nodes.open(opts.path);
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true) : nodes.open(opts.path, opts.pin);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -7320,7 +7329,8 @@ var WasmProcess = class {
         ...req.contents !== void 0 ? { contents: req.contents } : {},
         ...req.orphan ? { orphan: true } : {},
         ...req.truncate ? { truncate: true } : {},
-        ...req.create ? { create: true } : {}
+        ...req.create ? { create: true } : {},
+        ...req.pin ? { pin: req.pin } : {}
       },
       this.nodes
     );
@@ -7452,7 +7462,8 @@ var WasmProcess = class {
         position: req.position ?? 0,
         ...req.contents !== void 0 ? { contents: req.contents } : {},
         ...req.orphan ? { orphan: true } : {},
-        ...req.dirty ? { dirty: true } : {}
+        ...req.dirty ? { dirty: true } : {},
+        ...req.pin ? { pin: req.pin } : {}
       },
       this.nodes
     );