@ai-ecoverse/slicc-kernel 1.14.0 → 1.15.0

package/dist/kernel-worker.js

@@ -177,6 +177,37 @@ function openMeta(name2, factory) {
   });
 }
 
+// src/mount/media.ts
+var MEDIA_STORE = "handles";
+function memoryMedia() {
+  const handles = /* @__PURE__ */ new Map();
+  return {
+    get: async (id) => handles.get(id),
+    put: async (id, handle) => void handles.set(id, handle)
+  };
+}
+function settle2(request2, value) {
+  return new Promise((resolve, reject) => {
+    request2.onsuccess = () => resolve(value());
+    request2.onerror = () => reject(request2.error);
+  });
+}
+function openMedia(name2, factory) {
+  const request2 = factory.open(name2, 1);
+  request2.onupgradeneeded = () => request2.result.createObjectStore(MEDIA_STORE);
+  return settle2(request2, () => {
+    const db = request2.result;
+    const store = (mode) => db.transaction(MEDIA_STORE, mode).objectStore(MEDIA_STORE);
+    return {
+      get: (id) => {
+        const got = store("readonly").get(id);
+        return settle2(got, () => got.result);
+      },
+      put: (id, handle) => settle2(store("readwrite").put(handle, id), () => void 0)
+    };
+  });
+}
+
 // src/pin.ts
 function pinScript(url) {
   try {
@@ -643,7 +674,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;
@@ -3661,7 +3693,7 @@ function attachSyncSabResponder(port, sab, token, opts) {
     Atomics.notify(header2, SAB_I_PUB);
     if (offset + chunk2 >= entry.payload.byteLength) drop(id);
   }
-  function settle2(id, result) {
+  function settle3(id, result) {
     if (disposed) return;
     const { status, payload } = encodeSabResult(result);
     drop(id);
@@ -3680,7 +3712,7 @@ function attachSyncSabResponder(port, sab, token, opts) {
       const entry = pending.get(data.id);
       const offset = data.offset;
       if (!entry || typeof offset !== "number" || !Number.isInteger(offset) || offset < 0 || offset > entry.payload.byteLength) {
-        settle2(data.id, { ok: false, errno: "EIO", message: "sync-sab: bad continuation" });
+        settle3(data.id, { ok: false, errno: "EIO", message: "sync-sab: bad continuation" });
         return;
       }
       publish(data.id, entry, offset);
@@ -3694,7 +3726,7 @@ function attachSyncSabResponder(port, sab, token, opts) {
     try {
       dispatched = dispatch2(req);
     } catch (err) {
-      settle2(id, {
+      settle3(id, {
         ok: false,
         errno: "EIO",
         message: err instanceof Error ? err.message : String(err)
@@ -3702,8 +3734,8 @@ function attachSyncSabResponder(port, sab, token, opts) {
       return;
     }
     void dispatched.then(
-      (result) => settle2(id, result),
-      (err) => settle2(id, {
+      (result) => settle3(id, result),
+      (err) => settle3(id, {
         ok: false,
         errno: "EIO",
         message: err instanceof Error ? err.message : String(err)
@@ -5797,8 +5829,8 @@ function spawnWasmProcess(opts) {
     return dispatchSyncFs(req);
   };
   const responder = attachSyncSabResponder(worker, sab, token, { dispatch: dispatch2 });
-  let settle2;
-  const exited = new Promise((resolve) => settle2 = resolve);
+  let settle3;
+  const exited = new Promise((resolve) => settle3 = resolve);
   let done4 = false;
   let endedBy;
   const finish = (code, sig) => {
@@ -5813,8 +5845,8 @@ function spawnWasmProcess(opts) {
     opts.held?.delete(holds);
     worker.terminate();
     void process.exit().then(
-      () => settle2(code),
-      () => settle2(code)
+      () => settle3(code),
+      () => settle3(code)
     );
   };
   const handle = (data) => {
@@ -6127,6 +6159,148 @@ 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: 16749 };
+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/connection.ts
 var DRIVER_TIMEOUT_MS = 3e4;
 function unref(timer) {
@@ -6270,14 +6444,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;
@@ -6348,7 +6524,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);
@@ -7078,6 +7255,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;
@@ -7092,6 +7273,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 };
@@ -7355,7 +7538,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 });
@@ -7396,8 +7580,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);
@@ -7505,6 +7728,10 @@ function act2(session, req) {
 function dirsChannel(name2) {
   return name2 === false ? void 0 : `slicc-kernel-dirs:${name2}`;
 }
+async function stores(deps, name2) {
+  if (name2 === false) return {};
+  return { meta: await deps.metadata?.(name2), media: await deps.media?.(`${name2}:media`) };
+}
 function serveKernel(port, deps) {
   let launcher;
   let remote;
@@ -7556,7 +7783,7 @@ function serveKernel(port, deps) {
   async function init(req) {
     launcher = (req.root ? Promise.resolve(req.root) : deps.storage()).then(async (root) => {
       const name2 = req.metadata ?? META_DB;
-      const meta = name2 === false ? void 0 : await deps.metadata?.(name2);
+      const { meta, media } = await stores(deps, name2);
       remote = req.transport ? new RemoteTransport(port, req.transport) : void 0;
       const fs = new OpfsFs(root, meta, dirsChannel(name2));
       await fs.reconcile();
@@ -7567,6 +7794,8 @@ function serveKernel(port, deps) {
         ...req.modules ? { modules: req.modules } : {},
         ...req.env ? { env: req.env } : {},
         ...remote ? { transport: remote } : {},
+        ...media ? { media } : {},
+        onMountPending: (medium) => port.postMessage({ medium }),
         caStore: caStore(deps.metadata ? name2 : false)
       });
       await started.prepare();
@@ -7579,13 +7808,15 @@ function serveKernel(port, deps) {
     const l = await ready2();
     if (req.op === "mount") return l.mount(req.spec);
     if (req.op === "umount") return l.umount(req.target);
+    if (req.op === "insert") return l.insert(req.target, req.handle, req.source);
     return l.mounts.list();
   }
   async function handle(req) {
     if (req.op === "init") return init(req);
     if (req.op === "open-terminal") return terminal(req);
     if (req.op === "connect") return connect();
-    if (req.op === "mount" || req.op === "umount" || req.op === "mounts") return mountOp(req);
+    if (req.op === "mount" || req.op === "umount" || req.op === "mounts" || req.op === "insert")
+      return mountOp(req);
     if (req.op === "terminal") {
       const session = terminals.get(req.terminal);
       if (!session) throw new Error(`no terminal ${req.terminal}`);
@@ -7618,6 +7849,7 @@ serveKernel(globalThis, {
   storage: () => navigator.storage.getDirectory(),
   createWorker: () => new Worker(processWorker, { type: "module" }),
   createDriverWorker: () => new Worker(driverWorker, { type: "module" }),
-  metadata: (name2) => openMeta(name2, indexedDB)
+  metadata: (name2) => openMeta(name2, indexedDB),
+  media: (name2) => openMedia(name2, indexedDB)
 });
 //# sourceMappingURL=kernel-worker.js.map