@ai-ecoverse/slicc-kernel 1.4.0 → 1.5.0

package/dist/kernel-worker.js

@@ -59,34 +59,62 @@ function settle(transaction, value) {
 }
 var IndexedDbMeta = class {
   db;
+  cache = /* @__PURE__ */ new Map();
+  channel;
+  generation = 0;
   constructor(db) {
     this.db = db;
     db.onversionchange = () => db.close();
+    this.channel = new BroadcastChannel(`slicc-kernel-meta:${db.name}`);
+    this.channel.onmessage = ({ data }) => this.drop(data);
+    this.channel.unref?.();
+  }
+  drop({ paths = [], trees = [] }) {
+    this.generation++;
+    for (const path of paths) this.cache.delete(path);
+    for (const key of [...this.cache.keys()]) {
+      if (trees.some((tree) => under(key, tree))) this.cache.delete(key);
+    }
+  }
+  changed(invalidation) {
+    this.drop(invalidation);
+    this.channel.postMessage(invalidation);
   }
   transaction(mode) {
     const transaction = this.db.transaction(META_STORE, mode);
     return [transaction, transaction.objectStore(META_STORE)];
   }
   async get(paths) {
-    const [transaction, store] = this.transaction("readonly");
-    const found = paths.map(() => void 0);
-    paths.forEach((path, i) => {
-      const request2 = store.get(path);
-      request2.onsuccess = () => {
-        found[i] = request2.result;
-      };
-    });
-    return settle(transaction, () => found);
+    const missing3 = paths.filter((path) => !this.cache.has(path));
+    if (missing3.length > 0) {
+      const generation = this.generation;
+      const [transaction, store] = this.transaction("readonly");
+      const found = /* @__PURE__ */ new Map();
+      for (const path of missing3) {
+        const request2 = store.get(path);
+        request2.onsuccess = () => void found.set(path, request2.result ?? null);
+      }
+      await settle(transaction, () => void 0);
+      if (generation === this.generation)
+        for (const [path, entry] of found) this.cache.set(path, entry);
+      return paths.map(
+        (path) => (found.has(path) ? found.get(path) : this.cache.get(path)) ?? void 0
+      );
+    }
+    return paths.map((path) => this.cache.get(path) ?? void 0);
   }
   async update(path, change) {
     const [transaction, store] = this.transaction("readwrite");
     const request2 = store.get(path);
+    let next;
     request2.onsuccess = () => {
-      const next = change(request2.result);
+      next = change(request2.result);
       if (next) store.put(next);
       else store.delete(path);
     };
-    return settle(transaction, () => void 0);
+    await settle(transaction, () => void 0);
+    this.changed({ paths: [path] });
+    this.cache.set(path, next ?? null);
   }
   async move(from, to, root) {
     const [transaction, store] = this.transaction("readwrite");
@@ -102,7 +130,8 @@ var IndexedDbMeta = class {
       }
       store.put(moved(root(source.result), to));
     };
-    return settle(transaction, () => void 0);
+    await settle(transaction, () => void 0);
+    this.changed({ trees: [from, to] });
   }
   async remove(paths) {
     const [transaction, store] = this.transaction("readwrite");
@@ -110,7 +139,8 @@ var IndexedDbMeta = class {
       store.delete(path);
       store.delete(descendants(path));
     }
-    return settle(transaction, () => void 0);
+    await settle(transaction, () => void 0);
+    this.changed({ trees: paths });
   }
   async links(dir) {
     const [transaction, store] = this.transaction("readonly");
@@ -183,6 +213,7 @@ var S_IFLNK = 40960;
 var PERM_MASK = 4095;
 var READ_ATTEMPTS = 3;
 var MAX_LINKS = 40;
+var CHECK_MS = 1e3;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
@@ -222,37 +253,100 @@ function isHandle(child) {
 var OpfsFs = class {
   root;
   meta;
-  constructor(root, meta = new MemoryMeta()) {
+  dirs = /* @__PURE__ */ new Map();
+  checked = /* @__PURE__ */ new WeakMap();
+  channel;
+  constructor(root, meta = new MemoryMeta(), channel) {
     this.root = root;
     this.meta = meta;
+    this.channel = channel === void 0 ? void 0 : new BroadcastChannel(channel);
+    if (this.channel) {
+      this.channel.onmessage = ({ data }) => {
+        for (const path of data) this.forget(path);
+      };
+      this.channel.unref?.();
+    }
+  }
+  changed(...paths) {
+    for (const path of paths) this.forget(path);
+    this.channel?.postMessage(paths);
   }
   resolvePath(base, path) {
     return resolvePath(base, path);
   }
+  async walk(parts, from, start) {
+    let dir = start;
+    for (let at = from; at < parts.length; at++) {
+      dir = await dir.getDirectoryHandle(parts[at]);
+      this.dirs.set(`/${parts.slice(0, at + 1).join("/")}`, dir);
+      this.checked.set(dir, performance.now());
+    }
+    return dir;
+  }
   async dir(path) {
-    let dir = this.root;
+    const parts = split(path);
+    let from = parts.length;
+    let cached;
+    for (; from > 0 && !cached; from--)
+      cached = this.dirs.get(`/${parts.slice(0, from).join("/")}`);
+    if (cached) from++;
+    const at = `/${parts.slice(0, from).join("/")}`;
+    if (cached && !await this.current(at, cached)) {
+      this.forget(at);
+      cached = void 0;
+      from = 0;
+    }
     try {
-      for (const part of split(path)) dir = await dir.getDirectoryHandle(part);
+      return await this.walk(parts, from, cached ?? this.root);
     } catch (err) {
       throw translate(err, path);
     }
-    return dir;
+  }
+  async current(path, dir) {
+    if (performance.now() - (this.checked.get(dir) ?? -CHECK_MS) < CHECK_MS) return true;
+    const where = await this.root.resolve(dir).catch(() => null);
+    if (where === null || `/${where.join("/")}` !== path) return false;
+    this.checked.set(dir, performance.now());
+    return true;
+  }
+  forget(path) {
+    for (const key of [...this.dirs.keys()]) if (within(key, path)) this.dirs.delete(key);
+  }
+  async inDir(path, op) {
+    const dir = await this.dir(path);
+    try {
+      return await op(dir);
+    } catch (err) {
+      if (err?.name !== "NotFoundError" || await this.current(path, dir))
+        throw err;
+      this.forget(path);
+      return op(await this.dir(path));
+    }
+  }
+  async child(parent, name2, kind) {
+    return kind === "file" ? parent.getFileHandle(name2) : parent.getDirectoryHandle(name2);
   }
   async parent(path) {
     const parts = split(path);
     const name2 = parts.pop();
     if (name2 === void 0) throw fsError("EBUSY", path);
-    return [await this.dir(`/${parts.join("/")}`), name2];
+    return [`/${parts.join("/")}`, name2];
   }
   async handle(path) {
     if (split(path).length === 0) return this.root;
     const [dir, name2] = await this.parent(path);
-    try {
-      return await dir.getFileHandle(name2);
-    } catch (err) {
-      if (err?.name !== "TypeMismatchError") throw translate(err, path);
-    }
-    return dir.getDirectoryHandle(name2);
+    const known = this.dirs.has(path);
+    return this.inDir(dir, async (parent) => {
+      const [first, second] = known ? ["directory", "file"] : ["file", "directory"];
+      try {
+        return await this.child(parent, name2, first);
+      } catch (err) {
+        if (err?.name !== "TypeMismatchError") throw err;
+      }
+      return this.child(parent, name2, second);
+    }).catch((err) => {
+      throw translate(err, path);
+    });
   }
   real(path) {
     return this.handle(path).then(
@@ -354,24 +448,25 @@ var OpfsFs = class {
   }
   async writeTarget(path) {
     try {
-      return (await this.locate(path, true)).path;
+      return [(await this.locate(path, true)).path, true];
     } catch (err) {
       if (!missing(err)) throw err;
     }
     const [entry] = await this.meta.get([path]);
     const wanted = entry?.link === void 0 ? path : resolvePath(parentOf2(path), entry.link);
-    return resolvePath((await this.locate(parentOf2(wanted), true)).path, baseOf(wanted));
+    return [resolvePath((await this.locate(parentOf2(wanted), true)).path, baseOf(wanted)), false];
   }
   async writeFile(path, content) {
-    const target = await this.writeTarget(path);
+    const [target, existed] = await this.writeTarget(path);
     const [dir, name2] = await this.parent(target);
     let file;
     try {
-      file = await dir.getFileHandle(name2, { create: true });
+      file = await this.inDir(dir, (parent) => parent.getFileHandle(name2, { create: true }));
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
       throw code ? fsError(code, path) : translate(err, path);
     }
+    if (!existed && content.length === 0) return;
     const writable = await file.createWritable();
     await writable.write(content);
     await writable.close();
@@ -434,16 +529,21 @@ var OpfsFs = class {
     if (found.handle) {
       const [dir, name2] = await this.parent(found.path);
       try {
-        await dir.removeEntry(name2, { recursive: options.recursive === true });
+        await this.inDir(
+          dir,
+          (parent) => parent.removeEntry(name2, { recursive: options.recursive === true })
+        );
       } catch (err) {
         throw translate(err, path);
       }
+      this.changed(found.path);
     }
     await this.meta.remove([found.path]);
   }
   async rename(from, to) {
     if (from === to) return;
     const source = await this.locate(from, false);
+    this.forget(source.path);
     const parent = await this.locate(parentOf2(to), true);
     const destination = resolvePath(parent.path, baseOf(to));
     const sourceStat = await this.describe(source);
@@ -476,6 +576,7 @@ var OpfsFs = class {
     const name2 = baseOf(destination);
     const swap = targetStat?.isDirectory === true;
     const staging = swap ? `.${name2}.${crypto.randomUUID()}` : name2;
+    this.forget(destination);
     const timed = await this.explicitTimes(source.path);
     const moved2 = await this.place(source.handle, dir, staging);
     if (swap) await this.rm(destination, { recursive: true });
@@ -489,6 +590,7 @@ var OpfsFs = class {
       copied ||= !placed;
     }
     if (copied) await this.restamp(destination, timed);
+    this.changed(source.path, destination);
   }
   async modified(path) {
     const handle = await this.handle(path);
@@ -5798,6 +5900,9 @@ function act(session, req) {
   else if (req.action === "signal") session.signal(signalNumber(req.signal));
   else session.close();
 }
+function dirsChannel(name2) {
+  return name2 === false ? void 0 : `slicc-kernel-dirs:${name2}`;
+}
 function serveKernel(port, deps) {
   let launcher;
   let remote;
@@ -5824,7 +5929,7 @@ function serveKernel(port, deps) {
         const name2 = req.metadata ?? META_DB;
         const meta = name2 === false ? void 0 : await deps.metadata?.(name2);
         remote = req.transport ? new RemoteTransport(port, req.transport) : void 0;
-        const fs = new OpfsFs(root, meta);
+        const fs = new OpfsFs(root, meta, dirsChannel(name2));
         await fs.reconcile();
         const started = new Launcher({
           fs,