@ai-ecoverse/slicc-kernel 1.14.0 → 1.15.1

package/dist/node.js

@@ -585,7 +585,8 @@ var ERRNO_BY_DOM_ERROR = {
   TypeMismatchError: "ENOTDIR",
   InvalidModificationError: "ENOTEMPTY",
   NoModificationAllowedError: "EBUSY",
-  TypeError: "EINVAL"
+  TypeError: "EINVAL",
+  NotAllowedError: "EACCES"
 };
 function translate(err, path) {
   if (typeof err?.code === "string") return err;
@@ -5910,6 +5911,157 @@ function serveFilesystem(port, handlers, capabilities = {}) {
   return { invalidate: (paths) => reply({ invalidate: paths }) };
 }
 
+// src/mount/fsa.ts
+var FSA_CAPABILITIES = { listingStats: true };
+var codeOf = (err) => err?.code;
+var denied = (err) => codeOf(err) === "EACCES" || err?.name === "NotAllowedError";
+function attrOf(st) {
+  return {
+    kind: st.isDirectory ? "directory" : st.isSymbolicLink ? "symlink" : "file",
+    size: st.size,
+    mtime: st.mtime.getTime(),
+    mode: st.mode,
+    ino: st.ino
+  };
+}
+function kernelFsHandlers(fs) {
+  const handles = /* @__PURE__ */ new Map();
+  let nextFh = 0;
+  const handle = (fh) => {
+    const found = handles.get(fh);
+    if (!found) throw fsError2("EBADF", `handle ${fh}`);
+    return found;
+  };
+  async function existing(path) {
+    try {
+      return await fs.stat(path);
+    } catch (err) {
+      if (codeOf(err) === "ENOENT") return void 0;
+      throw err;
+    }
+  }
+  return {
+    getattr: async (path) => attrOf(await fs.lstat(path)),
+    readdir: async (path) => (await fs.readdirStat(path)).flatMap(([name2, st]) => {
+      if (!st) return [];
+      const attr = attrOf(st);
+      return [{ name: name2, kind: attr.kind, attr }];
+    }),
+    async open(path, flags) {
+      const st = await existing(path);
+      if (st && flags.exclusive) throw fsError2("EEXIST", path);
+      if (st?.isDirectory && flags.write) throw fsError2("EISDIR", path);
+      if (!st && !flags.create) throw fsError2("ENOENT", path);
+      const data = st && !flags.truncate ? await fs.readFileBuffer(path) : new Uint8Array(0);
+      handles.set(++nextFh, { path, data, length: data.length, dirty: !st || flags.truncate });
+      return nextFh;
+    },
+    async read(fh, offset, size) {
+      const h = handle(fh);
+      return h.data.slice(offset, Math.min(h.length, offset + size));
+    },
+    async write(fh, offset, bytes) {
+      const h = handle(fh);
+      const end = offset + bytes.length;
+      if (end > h.data.length) {
+        const grown = new Uint8Array(Math.max(end, h.data.length * 2));
+        grown.set(h.data.subarray(0, h.length));
+        h.data = grown;
+      }
+      h.data.set(bytes, offset);
+      h.length = Math.max(h.length, end);
+      h.dirty = true;
+    },
+    async release(fh) {
+      const h = handle(fh);
+      handles.delete(fh);
+      if (h.dirty) await fs.writeFile(h.path, h.data.slice(0, h.length));
+    },
+    mkdir: (path) => fs.mkdir(path),
+    async rmdir(path) {
+      if (!(await fs.lstat(path)).isDirectory) throw fsError2("ENOTDIR", path);
+      if ((await fs.readdir(path)).length > 0) throw fsError2("ENOTEMPTY", path);
+      await fs.rm(path);
+    },
+    async unlink(path) {
+      if ((await fs.lstat(path)).isDirectory) throw fsError2("EISDIR", path);
+      await fs.rm(path);
+    },
+    rename: (from, to) => fs.rename(from, to),
+    symlink: (target, path) => fs.symlink(target, path),
+    readlink: (path) => fs.readlink(path),
+    async setattr(path, change) {
+      if (change.mode !== void 0) await fs.chmod(path, change.mode);
+      if (change.mtime !== void 0) {
+        await fs.utimes(path, new Date(change.mtime), new Date(change.mtime));
+      }
+    }
+  };
+}
+var EMPTY_ROOT = { kind: "directory", size: 0, mtime: 0, mode: 16877 };
+function granted(handle) {
+  if (!handle.queryPermission) return Promise.resolve(true);
+  return handle.queryPermission({ mode: "readwrite" }).then(
+    (state) => state === "granted",
+    () => false
+  );
+}
+function removableMedium(onLost, open = (handle) => new OpfsFs(handle)) {
+  let current;
+  const absent = () => fsError2("ENOMEDIUM", "No medium found");
+  function wrap(pick) {
+    return async (...args) => {
+      const medium = current;
+      if (!medium) throw absent();
+      try {
+        return await pick(medium.handlers)(...args);
+      } catch (err) {
+        if (!denied(err) || await granted(medium.handle)) throw err;
+        if (current === medium) {
+          current = void 0;
+          onLost(medium.handle);
+        }
+        throw absent();
+      }
+    };
+  }
+  const getattr = wrap((h) => h.getattr);
+  const readdir = wrap((h) => h.readdir);
+  return {
+    handlers: {
+      getattr: (path) => current || path !== "/" ? getattr(path) : Promise.resolve(EMPTY_ROOT),
+      readdir: (path) => current || path !== "/" ? readdir(path) : Promise.resolve([]),
+      open: wrap((h) => h.open),
+      read: wrap((h) => h.read),
+      write: wrap((h) => h.write),
+      release: wrap((h) => h.release),
+      mkdir: wrap((h) => h.mkdir),
+      rmdir: wrap((h) => h.rmdir),
+      unlink: wrap((h) => h.unlink),
+      rename: wrap((h) => h.rename),
+      symlink: wrap((h) => h.symlink),
+      readlink: wrap((h) => h.readlink),
+      setattr: wrap((h) => h.setattr)
+    },
+    present: () => current !== void 0,
+    insert(handle) {
+      current = { handle, handlers: kernelFsHandlers(open(handle)) };
+    },
+    eject() {
+      current = void 0;
+    }
+  };
+}
+
+// src/mount/media.ts
+function memoryMedia() {
+  const handles = /* @__PURE__ */ new Map();
+  return {
+    get: async (id) => handles.get(id),
+    put: async (id, handle) => void handles.set(id, handle)
+  };
+}
+
 // src/mount/connection.ts
 var DRIVER_TIMEOUT_MS = 3e4;
 function unref(timer) {
@@ -6053,14 +6205,16 @@ var MountTable = class {
     this.deps = deps;
   }
   list() {
-    return [...this.mounts.values()].map(({ type, source, target, options, state, error }) => ({
-      type,
-      source,
-      target,
-      options: { ...options },
-      state,
-      ...error ? { error } : {}
-    }));
+    return [...this.mounts.values()].map(
+      ({ type, source, target, options, state, error, present }) => ({
+        type,
+        source,
+        target,
+        options: { ...options },
+        state: state === "ok" && present?.() === false ? "nomedium" : state,
+        ...error ? { error } : {}
+      })
+    );
   }
   locate(path) {
     let best;
@@ -6131,7 +6285,8 @@ var MountTable = class {
       maxFile: options.maxfile !== void 0 ? parseSize(options.maxfile) : caps.maxFile ?? 0,
       attrs: /* @__PURE__ */ new Map(),
       lists: /* @__PURE__ */ new Map(),
-      dispose: () => opened2.dispose()
+      dispose: () => opened2.dispose(),
+      ...opened2.present ? { present: opened2.present } : {}
     };
     mounted = mount;
     this.mounts.set(target, mount);
@@ -6861,6 +7016,10 @@ var Launcher = class {
   pnpmHome;
   mounts;
   createDriverWorker;
+  media;
+  onMountPending;
+  removable = /* @__PURE__ */ new Map();
+  inserted = /* @__PURE__ */ new Map();
   openFiles = /* @__PURE__ */ new Set();
   held = /* @__PURE__ */ new Set();
   nextPid = 1e3;
@@ -6875,6 +7034,8 @@ var Launcher = class {
     this.base = this.watchers.wrap(this.mounts.wrap(options.fs));
     this.createWorker = options.createWorker;
     this.createDriverWorker = options.createDriverWorker;
+    this.media = options.media ?? memoryMedia();
+    this.onMountPending = options.onMountPending;
     this.pnpmHome = options.env?.PNPM_HOME ?? PNPM_HOME;
     this.modulesDir = options.modules ?? "/node_modules";
     this.env = { ...networkEnv(), ...options.env };
@@ -7138,7 +7299,8 @@ var Launcher = class {
     if (sig !== 0) handle.signal(sig);
     return true;
   }
-  async driver(type, _spec) {
+  async driver(type, spec) {
+    if (type === "fsa") return this.fsaDriver(spec);
     if (type === "tmpfs") {
       const { port1, port2 } = new MessageChannel();
       serveFilesystem(port2, tmpfs(), { symlinks: true, chmod: true, attrTtl: 0 });
@@ -7179,8 +7341,47 @@ var Launcher = class {
       })
     };
   }
+  async fsaDriver(spec) {
+    const { target, source } = spec;
+    const ask = (handle) => this.onMountPending?.({ target, source, ...handle ? { handle } : {} });
+    const { port1, port2 } = new MessageChannel();
+    const medium = removableMedium((handle) => {
+      served.invalidate(true);
+      ask(handle);
+    });
+    const served = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
+    const id = source.slice("fsa:".length);
+    this.removable.set(target, { id, medium, served });
+    const stored = this.inserted.get(id) ?? await this.media.get(id);
+    if (stored && await granted(stored)) medium.insert(stored);
+    else ask(stored);
+    return {
+      port: port1,
+      present: () => medium.present(),
+      dispose: () => {
+        this.removable.delete(target);
+        port1.close();
+        port2.close();
+      }
+    };
+  }
   mount(spec) {
-    return this.mounts.mount(spec, this.fs);
+    if (spec.type !== "fsa" || spec.source.startsWith("fsa:"))
+      return this.mounts.mount(spec, this.fs);
+    return this.mounts.mount({ ...spec, source: `fsa:${crypto.randomUUID()}` }, this.fs);
+  }
+  async insert(target, handle, source) {
+    const at = normalizePath(target);
+    const slot = this.removable.get(at);
+    if (!slot) throw fsError("EINVAL", `${at} is not a removable mount`);
+    if (source !== void 0 && source !== `fsa:${slot.id}`) {
+      throw fsError("EINVAL", `${at} is no longer the drive ${source}`);
+    }
+    if (!await granted(handle)) throw fsError("EACCES", `${at}: no permission for this folder`);
+    this.inserted.set(slot.id, handle);
+    await this.media.put(slot.id, handle);
+    slot.medium.insert(handle);
+    slot.served.invalidate(true);
   }
   umount(target) {
     this.mounts.umount(target);
@@ -7555,13 +7756,13 @@ async function holdLock(locks) {
   if (!locks) return { release() {
   } };
   const name2 = `slicc-kernel-client:${crypto.randomUUID()}`;
-  const granted = Promise.withResolvers();
+  const granted2 = Promise.withResolvers();
   const held = Promise.withResolvers();
   void locks.request(name2, () => {
-    granted.resolve();
+    granted2.resolve();
     return held.promise;
   });
-  await granted.promise;
+  await granted2.promise;
   return { name: name2, release: () => held.resolve() };
 }
 function concat6(chunks2) {