@ai-ecoverse/slicc-kernel 1.60.0 → 1.60.2

package/README.md

@@ -384,7 +384,7 @@ The proxy answers `200` with `Content-Type: application/vnd.slicc.raw-fetch`: a
 
 ## Filesystem
 
-`/` is the OPFS root. Each process mounts the top-level directories that exist when it starts (plus `/usr` and `/bin`), so files in them are shared by all processes and visible through the OPFS API as soon as the process that wrote them has closed them; `run` resolves only after that. `createKernel` creates `/tmp` and `/home` in OPFS, so they are shared too. Files directly in `/`, and directories created there after a process started, are OPFS as well, the same for Emscripten and WASI programs; only `/dev` and `/proc` live in each process's memory. File contents are buffered per open file and written back on close, `fsync` and exit; metadata operations (`mkdir`, `rename`, `rm`, …) go straight to OPFS. The kernel worker is the only writer.
+`/` is the OPFS root. Each process mounts the top-level directories that exist when it starts (plus `/usr` and `/bin`), so files in them are shared by all processes and visible through the OPFS API as soon as the process that wrote them has closed them; `run` resolves only after that. `createKernel` creates `/tmp` and `/home` in OPFS, so they are shared too. Files directly in `/`, and directories created there after a process started, are OPFS as well, the same for Emscripten and WASI programs; only `/dev` and `/proc` live in each process's memory. A program's `mkdir` (WASI `path_create_directory`, Emscripten's `mkdir`) is exclusive, as on Linux: it fails with `EEXIST` when the name exists, and of several processes or threads making one name at once exactly one succeeds, so a directory works as a lock. Unlike Linux, a WASI program's `mkdir` under a missing directory makes the missing parents rather than failing with `ENOENT` (#380); a JS program's `ctx.fs.mkdir` makes parents too. An OPFS or IndexedDB failure that has no POSIX counterpart is `EIO`; its message names the DOM error and the operation (`lookup`, `read`, `write`, `commit` or `sidecar`), and the kernel worker logs the first of each kind to its console. File contents are buffered per open file and written back on close, `fsync` and exit; metadata operations (`mkdir`, `rename`, `rm`, …) go straight to OPFS. The kernel worker is the only writer.
 
 Directories are renamed with `FileSystemHandle.move()` where available, else by copy and delete.
 

package/dist/kernel-worker.js

@@ -294,10 +294,31 @@ var ERRNO_BY_DOM_ERROR = {
   TypeError: "EINVAL",
   NotAllowedError: "EACCES"
 };
-function translate(err, path) {
+var reported = /* @__PURE__ */ new Set();
+function translate(err, path, op = "lookup", mapped = true) {
   if (typeof err?.code === "string") return err;
-  const name2 = err?.name;
-  return fsError(typeof name2 === "string" && ERRNO_BY_DOM_ERROR[name2] || "EIO", path);
+  const raw = err?.name;
+  const name2 = typeof raw === "string" ? raw : "Error";
+  const code = mapped && ERRNO_BY_DOM_ERROR[name2] || "EIO";
+  const error = Object.assign(fsError(code, path), { domName: name2, op, cause: err });
+  if (code !== "EIO") return error;
+  const detail = err?.message;
+  error.message += ` (OPFS ${op}: ${name2}${typeof detail === "string" && detail ? `: ${detail}` : ""})`;
+  if (!reported.has(`${name2}/${op}`)) {
+    reported.add(`${name2}/${op}`);
+    console.warn(
+      `slicc-kernel: ${error.message}, reported as EIO; logged once per error and operation`
+    );
+  }
+  return error;
+}
+var META_OPS = ["get", "update", "move", "remove", "links", "under", "all"];
+function sidecar(meta) {
+  const pathOf = ([first]) => [first, "/"].flat().find((p) => typeof p === "string");
+  const guarded = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
+    throw translate(err, pathOf(args), "sidecar", false);
+  });
+  return Object.fromEntries(META_OPS.map((op) => [op, guarded(op)]));
 }
 function missing(err) {
   const code = err?.code;
@@ -386,7 +407,7 @@ var OpfsFs = class {
   owners = false;
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
-    this.meta = meta;
+    this.meta = sidecar(meta);
     this.ranged = options.ranged === true;
     this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
     if (this.channel) {
@@ -691,7 +712,8 @@ var OpfsFs = class {
       } catch (err) {
         const name2 = err?.name;
         const again = name2 === "NotReadableError" || locks && LOCKED.has(name2);
-        if (!again || attempt >= READ_ATTEMPTS) throw translate(err, path);
+        if (!again || attempt >= READ_ATTEMPTS)
+          throw translate(err, path, locks ? "write" : "read");
         await new Promise((resolve) => setTimeout(resolve, attempt * 10));
       }
     }
@@ -733,9 +755,15 @@ var OpfsFs = class {
       true
     );
     return {
-      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }),
-      truncate: (size) => writable.truncate(size),
-      close: () => writable.close()
+      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }).catch((err) => {
+        throw translate(err, path, "write", false);
+      }),
+      truncate: (size) => writable.truncate(size).catch((err) => {
+        throw translate(err, path, "write", false);
+      }),
+      close: () => writable.close().catch((err) => {
+        throw translate(err, path, "commit", false);
+      })
     };
   }
   async readFile(path) {
@@ -770,9 +798,13 @@ var OpfsFs = class {
     const [file, existed, target] = await this.fileFor(path);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
-    const writable = await file.createWritable();
-    await writable.write(content);
-    await writable.close();
+    try {
+      const writable = await file.createWritable();
+      await writable.write(content);
+      await writable.close();
+    } catch (err) {
+      throw translate(err, path, "commit", false);
+    }
   }
   async listing(path) {
     const found = await this.locate(path, true);
@@ -1048,6 +1080,49 @@ var OpfsFs = class {
     return removed;
   }
 };
+var READS = [
+  "stat",
+  "lstat",
+  "exists",
+  "readFile",
+  "readFileBuffer",
+  "pread",
+  "readdir",
+  "readdirStat",
+  "readlink",
+  "realpath"
+];
+var WRITES = [
+  "writeFile",
+  "pwrite",
+  "truncate",
+  "writeSession",
+  "mkdir",
+  "rm",
+  "link",
+  "rename",
+  "symlink",
+  "chmod",
+  "utimes",
+  "lutimes",
+  "chown"
+];
+for (const [names, op] of [
+  [READS, "read"],
+  [WRITES, "write"]
+]) {
+  for (const name2 of names) {
+    const proto = OpfsFs.prototype;
+    const inner = proto[name2];
+    proto[name2] = async function(...args) {
+      try {
+        return await inner.apply(this, args);
+      } catch (err) {
+        throw translate(err, String(args[0]), op, false);
+      }
+    };
+  }
+}
 
 // src/mount/media.ts
 var MEDIA_STORE = "handles";
@@ -7734,6 +7809,19 @@ function mkdirOptions(entry, mode = 511) {
   const parents = 511 & ~(entry.umask?.() ?? 18) | 192;
   return { recursive: true, owner: { ...owner, parents } };
 }
+async function mkdirExclusive(entry, path, mode) {
+  const { fs } = entry;
+  const { owner } = mkdirOptions(entry, mode);
+  const own = owner ? { owner } : {};
+  try {
+    await fs.mkdir(path, own);
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+    const above = owner ? { owner: { ...owner, mode: owner.parents } } : {};
+    await fs.mkdir(path.slice(0, path.lastIndexOf("/")) || "/", { recursive: true, ...above });
+    await fs.mkdir(path, own);
+  }
+}
 async function chown(entry, path, req) {
   const cred = entry.cred?.();
   if (!cred) {
@@ -7766,7 +7854,7 @@ async function run(entry, path, req) {
     case "readdir-stat":
       return json2(await readdirStat(fs, path));
     case "mkdir":
-      await fs.mkdir(path, mkdirOptions(entry, req.mode));
+      await (req.exclusive ? mkdirExclusive(entry, path, req.mode) : fs.mkdir(path, mkdirOptions(entry, req.mode)));
       return done;
     case "rm":
       await fs.rm(path, { recursive: true });
@@ -11318,9 +11406,9 @@ var Dying = class {
   clear() {
     clearTimeout(this.timer);
   }
-  status(reported) {
+  status(reported2) {
     if (this.ending) return [this.ending.code, this.ending.sig];
-    return [typeof reported === "number" ? reported : CRASHED, void 0];
+    return [typeof reported2 === "number" ? reported2 : CRASHED, void 0];
   }
 };
 function killThread(thread, caught, sig) {