@ai-ecoverse/slicc-kernel 1.60.0 → 1.60.2

package/dist/node.js

@@ -2520,10 +2520,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;
@@ -2608,7 +2629,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) {
@@ -2913,7 +2934,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));
       }
     }
@@ -2955,9 +2977,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) {
@@ -2992,9 +3020,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);
@@ -3270,6 +3302,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/fs/unlinked.ts
 var UNLINKED_DIR = ".slicc-unlinked";
@@ -6159,6 +6234,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) {
@@ -6191,7 +6279,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 });
@@ -11091,9 +11179,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) {