@ai-ecoverse/slicc-kernel 1.1.0 → 1.2.0

package/dist/kernel-worker.js

@@ -1,3 +1,152 @@
+// src/fs/meta.ts
+var META_DB = "slicc-kernel";
+var META_VERSION = 1;
+var META_STORE = "entries";
+function parentOf(path) {
+  return path.slice(0, path.lastIndexOf("/")) || "/";
+}
+function moved(entry, path) {
+  return entry.link === void 0 ? { ...entry, path } : { ...entry, path, dir: parentOf(path) };
+}
+function under(path, root) {
+  return path === root || path.startsWith(`${root}/`);
+}
+var MemoryMeta = class {
+  entries = /* @__PURE__ */ new Map();
+  async get(paths) {
+    return paths.map((path) => this.entries.get(path));
+  }
+  async update(path, change) {
+    this.set(path, change(this.entries.get(path)));
+  }
+  set(path, entry) {
+    if (entry) this.entries.set(path, entry);
+    else this.entries.delete(path);
+  }
+  async move(from, to, root) {
+    await this.remove([to]);
+    const carried = [...this.entries.values()].filter((entry) => under(entry.path, from));
+    for (const entry of carried) this.entries.delete(entry.path);
+    for (const entry of carried) {
+      const path = to + entry.path.slice(from.length);
+      if (path !== to) this.entries.set(path, moved(entry, path));
+    }
+    this.entries.set(to, moved(root(carried.find((entry) => entry.path === from)), to));
+  }
+  async remove(paths) {
+    for (const key of [...this.entries.keys()]) {
+      if (paths.some((path) => under(key, path))) this.entries.delete(key);
+    }
+  }
+  async links(dir) {
+    return [...this.entries.values()].filter((entry) => entry.dir === dir);
+  }
+  async under(path) {
+    return [...this.entries.values()].filter((entry) => under(entry.path, path));
+  }
+  async all() {
+    return [...this.entries.values()];
+  }
+};
+function descendants(path) {
+  return IDBKeyRange.bound(`${path}/`, `${path}0`, false, true);
+}
+function settle(transaction, value) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve(value());
+    transaction.onabort = () => reject(transaction.error ?? new Error("metadata transaction aborted"));
+  });
+}
+var IndexedDbMeta = class {
+  db;
+  constructor(db) {
+    this.db = db;
+    db.onversionchange = () => db.close();
+  }
+  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 request = store.get(path);
+      request.onsuccess = () => {
+        found[i] = request.result;
+      };
+    });
+    return settle(transaction, () => found);
+  }
+  async update(path, change) {
+    const [transaction, store] = this.transaction("readwrite");
+    const request = store.get(path);
+    request.onsuccess = () => {
+      const next = change(request.result);
+      if (next) store.put(next);
+      else store.delete(path);
+    };
+    return settle(transaction, () => void 0);
+  }
+  async move(from, to, root) {
+    const [transaction, store] = this.transaction("readwrite");
+    store.delete(to);
+    store.delete(descendants(to));
+    const source = store.get(from);
+    const below = store.getAll(descendants(from));
+    below.onsuccess = () => {
+      store.delete(from);
+      store.delete(descendants(from));
+      for (const entry of below.result) {
+        store.put(moved(entry, to + entry.path.slice(from.length)));
+      }
+      store.put(moved(root(source.result), to));
+    };
+    return settle(transaction, () => void 0);
+  }
+  async remove(paths) {
+    const [transaction, store] = this.transaction("readwrite");
+    for (const path of paths) {
+      store.delete(path);
+      store.delete(descendants(path));
+    }
+    return settle(transaction, () => void 0);
+  }
+  async links(dir) {
+    const [transaction, store] = this.transaction("readonly");
+    const request = store.index("dir").getAll(dir);
+    return settle(transaction, () => request.result);
+  }
+  async under(path) {
+    const [transaction, store] = this.transaction("readonly");
+    const self = store.get(path);
+    const below = store.getAll(descendants(path));
+    return settle(
+      transaction,
+      () => [self.result, ...below.result].filter(
+        (entry) => entry !== void 0
+      )
+    );
+  }
+  async all() {
+    const [transaction, store] = this.transaction("readonly");
+    const request = store.getAll();
+    return settle(transaction, () => request.result);
+  }
+};
+function openMeta(name, factory) {
+  return new Promise((resolve, reject) => {
+    const request = factory.open(name, META_VERSION);
+    request.onupgradeneeded = (event) => {
+      if (event.oldVersion < 1) {
+        request.result.createObjectStore(META_STORE, { keyPath: "path" }).createIndex("dir", "dir");
+      }
+    };
+    request.onsuccess = () => resolve(new IndexedDbMeta(request.result));
+    request.onerror = () => reject(request.error);
+  });
+}
+
 // src/fs/types.ts
 function fsError(code, path) {
   return Object.assign(new Error(`${code}: ${path}`), { code });
@@ -14,12 +163,26 @@ function normalizePath(path) {
 function resolvePath(base, path) {
   return normalizePath(path.startsWith("/") ? path : `${base}/${path}`);
 }
+function inodeOf(path) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < path.length; i++) {
+    const c = path.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 2654435761);
+    h2 = Math.imul(h2 ^ c, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0) || 1;
+}
 
 // src/fs/opfs.ts
 var S_IFDIR = 16384;
 var S_IFREG = 32768;
+var S_IFLNK = 40960;
 var PERM_MASK = 4095;
 var READ_ATTEMPTS = 3;
+var MAX_LINKS = 40;
 var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
 var ERRNO_BY_DOM_ERROR = {
   NotFoundError: "ENOENT",
@@ -33,26 +196,43 @@ function translate(err, path) {
   const name = err?.name;
   return fsError(typeof name === "string" && ERRNO_BY_DOM_ERROR[name] || "EIO", path);
 }
+function missing(err) {
+  const code = err?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
 function split(path) {
   return path.split("/").filter(Boolean);
 }
+function parentOf2(path) {
+  return path.slice(0, path.lastIndexOf("/")) || "/";
+}
+function baseOf(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function prefixes(path) {
+  const parts = split(path);
+  return parts.map((_, i) => `/${parts.slice(0, i + 1).join("/")}`);
+}
 function within(path, root) {
   return path === root || path.startsWith(`${root}/`);
 }
+function isHandle(child) {
+  return "kind" in child;
+}
 var OpfsFs = class {
-  modes = /* @__PURE__ */ new Map();
-  times = /* @__PURE__ */ new Map();
   root;
-  constructor(root) {
+  meta;
+  constructor(root, meta = new MemoryMeta()) {
     this.root = root;
+    this.meta = meta;
   }
   resolvePath(base, path) {
     return resolvePath(base, path);
   }
-  async dir(path, create = false) {
+  async dir(path) {
     let dir = this.root;
     try {
-      for (const part of split(path)) dir = await dir.getDirectoryHandle(part, { create });
+      for (const part of split(path)) dir = await dir.getDirectoryHandle(part);
     } catch (err) {
       throw translate(err, path);
     }
@@ -74,34 +254,89 @@ var OpfsFs = class {
     }
     return dir.getDirectoryHandle(name);
   }
-  mode(path, directory) {
+  real(path) {
+    return this.handle(path).then(
+      () => true,
+      () => false
+    );
+  }
+  async linkAlong(path) {
+    for (const entry of await this.meta.get(prefixes(path))) {
+      if (entry?.link === void 0) continue;
+      if (!await this.real(entry.path) && await this.real(parentOf2(entry.path))) return entry;
+    }
+    return void 0;
+  }
+  async locate(path, follow) {
+    let current = path;
+    for (let hops = 0; hops <= MAX_LINKS; hops++) {
+      try {
+        return { path: current, handle: await this.handle(current) };
+      } catch (err) {
+        if (!missing(err)) throw err;
+        const link = await this.linkAlong(current);
+        if (!link) throw err;
+        if (link.path === current && !follow) return { path: current, link };
+        const rest = current.slice(link.path.length);
+        current = resolvePath(parentOf2(link.path), `${link.link}${rest}`);
+      }
+    }
+    throw fsError("ELOOP", path);
+  }
+  mode(path, directory, meta) {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
-    return (directory ? S_IFDIR : S_IFREG) | (this.modes.get(path) ?? fallback);
+    return (directory ? S_IFDIR : S_IFREG) | (meta?.mode ?? fallback);
   }
-  async stat(path) {
-    const handle = await this.handle(path);
+  async statOf(path, handle, meta) {
     const directory = handle.kind === "directory";
     const file = directory ? void 0 : await handle.getFile();
+    const modified = file?.lastModified ?? 0;
+    const mtime = meta?.mtimeMs !== void 0 && meta.mtimeFor === modified ? meta.mtimeMs : modified;
     return {
       isFile: !directory,
       isDirectory: directory,
       isSymbolicLink: false,
       size: file?.size ?? 0,
-      mode: this.mode(path, directory),
-      mtime: new Date(this.times.get(path) ?? file?.lastModified ?? 0)
+      mode: this.mode(path, directory, meta),
+      mtime: new Date(mtime),
+      atime: new Date(meta?.atimeMs ?? mtime),
+      ctime: new Date(Math.max(meta?.ctimeMs ?? mtime, modified)),
+      ino: meta?.ino ?? inodeOf(path)
+    };
+  }
+  linkStat(entry) {
+    const time = new Date(entry.mtimeMs ?? 0);
+    return {
+      isFile: false,
+      isDirectory: false,
+      isSymbolicLink: true,
+      size: new TextEncoder().encode(entry.link).length,
+      mode: S_IFLNK | 511,
+      mtime: time,
+      atime: time,
+      ctime: new Date(entry.ctimeMs ?? 0),
+      ino: entry.ino ?? inodeOf(entry.path)
     };
   }
-  lstat(path) {
-    return this.stat(path);
+  async describe(found) {
+    if (found.link) return this.linkStat(found.link);
+    const [meta] = await this.meta.get([found.path]);
+    return this.statOf(found.path, found.handle, meta);
+  }
+  async stat(path) {
+    return this.describe(await this.locate(path, true));
+  }
+  async lstat(path) {
+    return this.describe(await this.locate(path, false));
   }
   async exists(path) {
-    return this.handle(path).then(
+    return this.locate(path, true).then(
       () => true,
       () => false
     );
   }
   async readFileBuffer(path) {
-    const handle = await this.handle(path);
+    const handle = (await this.locate(path, true)).handle;
     if (handle.kind === "directory") throw fsError("EISDIR", path);
     for (let attempt = 1; ; attempt++) {
       try {
@@ -117,8 +352,19 @@ var OpfsFs = class {
   async readFile(path) {
     return new TextDecoder().decode(await this.readFileBuffer(path));
   }
+  async writeTarget(path) {
+    try {
+      return (await this.locate(path, true)).path;
+    } 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));
+  }
   async writeFile(path, content) {
-    const [dir, name] = await this.parent(path);
+    const target = await this.writeTarget(path);
+    const [dir, name] = await this.parent(target);
     let file;
     try {
       file = await dir.getFileHandle(name, { create: true });
@@ -129,77 +375,146 @@ var OpfsFs = class {
     const writable = await file.createWritable();
     await writable.write(content);
     await writable.close();
-    this.times.delete(path);
   }
-  async readdir(path) {
-    const handle = await this.handle(path);
+  async listing(path) {
+    const found = await this.locate(path, true);
+    const handle = found.handle;
     if (handle.kind !== "directory") throw fsError("ENOTDIR", path);
-    const names = [];
-    for await (const name of handle.keys()) names.push(name);
-    return names.sort();
+    const children = /* @__PURE__ */ new Map();
+    for await (const child of handle.values()) children.set(child.name, child);
+    for (const link of await this.meta.links(found.path)) {
+      const name = baseOf(link.path);
+      if (!children.has(name)) children.set(name, link);
+    }
+    return [found.path, [...children].sort(([a], [b]) => a < b ? -1 : 1)];
+  }
+  async readdir(path) {
+    return (await this.listing(path))[1].map(([name]) => name);
+  }
+  async readdirStat(path) {
+    const [dir, children] = await this.listing(path);
+    const base = dir === "/" ? "" : dir;
+    const metas = await this.meta.get(children.map(([name]) => `${base}/${name}`));
+    return Promise.all(
+      children.map(async ([name, child], i) => {
+        if (!isHandle(child)) return [name, this.linkStat(child)];
+        const stat = await this.statOf(`${base}/${name}`, child, metas[i]).catch(() => null);
+        return [name, stat];
+      })
+    );
   }
   async mkdir(path, options = {}) {
-    if (options.recursive) {
-      await this.dir(path, true);
-      return;
+    let found;
+    try {
+      found = await this.locate(path, true);
+    } catch (err) {
+      if (!missing(err)) throw err;
     }
-    if (await this.exists(path)) throw fsError("EEXIST", path);
-    const [dir, name] = await this.parent(path);
-    await dir.getDirectoryHandle(name, { create: true });
+    if (found) {
+      const directory = found.handle?.kind === "directory";
+      if (options.recursive && directory) return;
+      throw fsError(options.recursive ? "ENOTDIR" : "EEXIST", path);
+    }
+    const [entry] = await this.meta.get([path]);
+    if (entry?.link !== void 0) throw fsError("EEXIST", path);
+    if (options.recursive) await this.mkdir(parentOf2(path), options);
+    const parent = await this.locate(parentOf2(path), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
+    await parent.handle.getDirectoryHandle(baseOf(path), { create: true });
   }
   async rm(path, options = {}) {
+    let found;
     try {
-      const [dir, name] = await this.parent(path);
-      await dir.removeEntry(name, { recursive: options.recursive === true });
+      found = await this.locate(path, false);
     } catch (err) {
       const error = translate(err, path);
       if (options.force && error.code === "ENOENT") return;
       throw error;
     }
-    this.forget(path);
-  }
-  forget(path) {
-    for (const map of [this.modes, this.times]) {
-      for (const key of [...map.keys()]) if (within(key, path)) map.delete(key);
-    }
-  }
-  carry(from, to) {
-    for (const map of [this.modes, this.times]) {
-      for (const [key, value] of [...map]) {
-        if (!within(key, from)) continue;
-        map.delete(key);
-        map.set(to + key.slice(from.length), value);
+    if (found.handle) {
+      const [dir, name] = await this.parent(found.path);
+      try {
+        await dir.removeEntry(name, { recursive: options.recursive === true });
+      } catch (err) {
+        throw translate(err, path);
       }
     }
+    await this.meta.remove([found.path]);
   }
   async rename(from, to) {
     if (from === to) return;
-    const source = await this.stat(from);
-    if (source.isDirectory && within(to, from)) throw fsError("EINVAL", to);
-    const target = await this.stat(to).catch(() => null);
-    if (target?.isDirectory && !source.isDirectory) throw fsError("EISDIR", to);
-    if (target && !target.isDirectory && source.isDirectory) throw fsError("ENOTDIR", to);
-    if (target?.isDirectory && (await this.readdir(to)).length > 0) {
+    const source = await this.locate(from, false);
+    const parent = await this.locate(parentOf2(to), true);
+    const destination = resolvePath(parent.path, baseOf(to));
+    const sourceStat = await this.describe(source);
+    if (sourceStat.isDirectory && within(destination, source.path)) throw fsError("EINVAL", to);
+    const target = await this.locate(destination, false).catch((err) => {
+      if (missing(err)) return null;
+      throw err;
+    });
+    const targetStat = target && await this.describe(target);
+    if (targetStat?.isDirectory && !sourceStat.isDirectory) throw fsError("EISDIR", to);
+    if (targetStat && !targetStat.isDirectory && sourceStat.isDirectory) {
+      throw fsError("ENOTDIR", to);
+    }
+    if (targetStat?.isDirectory && (await this.readdir(destination)).length > 0) {
       throw fsError("ENOTEMPTY", to);
     }
-    const [dir, name] = await this.parent(to);
-    const handle = await this.handle(from);
-    const swap = target?.isDirectory === true;
+    const now = Date.now();
+    const carry = (entry) => ({
+      ino: inodeOf(source.path),
+      ...entry,
+      path: destination,
+      ctimeMs: now
+    });
+    if (source.link) {
+      if (target?.handle) await this.rm(destination);
+      await this.meta.move(source.path, destination, carry);
+      return;
+    }
+    const dir = parent.handle;
+    const name = baseOf(destination);
+    const swap = targetStat?.isDirectory === true;
     const staging = swap ? `.${name}.${crypto.randomUUID()}` : name;
-    const moved = await this.place(handle, dir, staging);
-    if (swap) await this.rm(to, { recursive: true });
-    this.carry(from, to);
-    if (!moved) await this.rm(from, { recursive: true });
-    if (!swap) return;
-    const staged = await dir.getDirectoryHandle(staging);
-    if (!await this.place(staged, dir, name)) await dir.removeEntry(staging, { recursive: true });
+    const timed = await this.explicitTimes(source.path);
+    const moved2 = await this.place(source.handle, dir, staging);
+    if (swap) await this.rm(destination, { recursive: true });
+    await this.meta.move(source.path, destination, carry);
+    if (!moved2) await this.rm(source.path, { recursive: true });
+    let copied = !moved2;
+    if (swap) {
+      const staged = await dir.getDirectoryHandle(staging);
+      const placed = await this.place(staged, dir, name);
+      if (!placed) await dir.removeEntry(staging, { recursive: true });
+      copied ||= !placed;
+    }
+    if (copied) await this.restamp(destination, timed);
+  }
+  async modified(path) {
+    const handle = await this.handle(path);
+    return handle.kind === "file" ? (await handle.getFile()).lastModified : 0;
+  }
+  async explicitTimes(path) {
+    const timed = [];
+    for (const entry of await this.meta.under(path)) {
+      if (entry.mtimeFor === void 0 || entry.link !== void 0) continue;
+      const current = await this.modified(entry.path).catch(() => void 0);
+      if (current === entry.mtimeFor) timed.push(entry.path.slice(path.length));
+    }
+    return timed;
+  }
+  async restamp(path, timed) {
+    for (const rest of timed) {
+      const mtimeFor = await this.modified(path + rest);
+      await this.meta.update(path + rest, (entry) => entry && { ...entry, mtimeFor });
+    }
   }
   async place(handle, dir, name) {
-    const moved = await handle.move?.(dir, name).then(
+    const moved2 = await handle.move?.(dir, name).then(
       () => true,
       () => false
     );
-    if (moved) return true;
+    if (moved2) return true;
     try {
       await this.copy(handle, dir, name);
     } catch (err) {
@@ -218,20 +533,65 @@ var OpfsFs = class {
     const target = await dir.getDirectoryHandle(name, { create: true });
     for await (const child of handle.values()) await this.copy(child, target, child.name);
   }
-  async symlink(_target, path) {
-    throw fsError("ENOSYS", path);
+  async symlink(target, path) {
+    const parent = await this.locate(parentOf2(path), true);
+    if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
+    const at = resolvePath(parent.path, baseOf(path));
+    if (await this.locate(at, false).then(
+      () => true,
+      (err) => !missing(err)
+    )) {
+      throw fsError("EEXIST", path);
+    }
+    const now = Date.now();
+    await this.meta.update(at, () => ({
+      path: at,
+      link: target,
+      dir: parent.path,
+      ino: inodeOf(at),
+      mtimeMs: now,
+      ctimeMs: now
+    }));
   }
   async readlink(path) {
-    await this.handle(path);
+    const found = await this.locate(path, false);
+    if (found.link) return found.link.link;
     throw fsError("EINVAL", path);
   }
   async chmod(path, mode) {
-    await this.handle(path);
-    this.modes.set(path, mode & PERM_MASK);
-  }
-  async utimes(path, _atime, mtime) {
-    await this.handle(path);
-    this.times.set(path, mtime.getTime());
+    const found = await this.locate(path, true);
+    const ctimeMs = Date.now();
+    await this.meta.update(found.path, (entry) => ({
+      ...entry,
+      path: found.path,
+      mode: mode & PERM_MASK,
+      ctimeMs
+    }));
+  }
+  async utimes(path, atime, mtime) {
+    const found = await this.locate(path, true);
+    const handle = found.handle;
+    const file = handle.kind === "file" ? await handle.getFile() : void 0;
+    const ctimeMs = Date.now();
+    await this.meta.update(found.path, (entry) => ({
+      ...entry,
+      path: found.path,
+      atimeMs: atime.getTime(),
+      mtimeMs: mtime.getTime(),
+      mtimeFor: file?.lastModified ?? 0,
+      ctimeMs
+    }));
+  }
+  async reconcile() {
+    let removed = 0;
+    for (const entry of await this.meta.all()) {
+      const real = await this.real(entry.path);
+      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf2(entry.path));
+      if (!stale) continue;
+      await this.meta.update(entry.path, () => void 0);
+      removed++;
+    }
+    return removed;
   }
 };
 
@@ -380,19 +740,34 @@ async function scanCommands(fs, modules) {
 var S_IFDIR2 = 16384;
 var S_IFREG2 = 32768;
 var COMMAND = /^\/(?:usr\/)?bin\/([^/]+)$/;
-function missing(err) {
+var MAX_LINKS2 = 40;
+function missing2(err) {
   return err?.code === "ENOENT";
 }
-function synthetic(directory) {
+function synthetic(directory, path) {
+  const epoch = /* @__PURE__ */ new Date(0);
   return {
     isFile: !directory,
     isDirectory: directory,
     isSymbolicLink: false,
     size: 0,
     mode: (directory ? S_IFDIR2 : S_IFREG2) | 493,
-    mtime: /* @__PURE__ */ new Date(0)
+    mtime: epoch,
+    atime: epoch,
+    ctime: epoch,
+    ino: inodeOf(path)
   };
 }
+async function followLinks(fs, path) {
+  let current = path;
+  for (let hops = 0; hops < MAX_LINKS2; hops++) {
+    const st = await fs.lstat(current).catch(() => void 0);
+    if (!st?.isSymbolicLink) return current;
+    const parent = current.slice(0, current.lastIndexOf("/")) || "/";
+    current = fs.resolvePath(parent, await fs.readlink(current));
+  }
+  return current;
+}
 function withCommandDirs(fs, names) {
   async function children(path) {
     if (path === "/") return ["bin", "usr"];
@@ -401,15 +776,18 @@ function withCommandDirs(fs, names) {
     return void 0;
   }
   async function virtual(path) {
-    if (path === "/usr" || path === "/bin" || path === "/usr/bin") return synthetic(true);
+    if (path === "/usr" || path === "/bin" || path === "/usr/bin") return synthetic(true, path);
     const name = COMMAND.exec(path)?.[1];
-    return name !== void 0 && (await names()).has(name) ? synthetic(false) : void 0;
+    return name !== void 0 && (await names()).has(name) ? synthetic(false, path) : void 0;
+  }
+  async function linked(path) {
+    return await virtual(path) ?? virtual(await followLinks(fs, path));
   }
   async function stat(path, real) {
     try {
       return await real(path);
     } catch (err) {
-      const found = missing(err) ? await virtual(path) : void 0;
+      const found = missing2(err) ? await linked(path) : void 0;
       if (found) return found;
       throw err;
     }
@@ -421,13 +799,13 @@ function withCommandDirs(fs, names) {
       try {
         return await fs.readFileBuffer(path);
       } catch (err) {
-        if (missing(err) && (await virtual(path))?.isFile) return new Uint8Array(0);
+        if (missing2(err) && (await linked(path))?.isFile) return new Uint8Array(0);
         throw err;
       }
     },
     writeFile: (path, content) => fs.writeFile(path, content),
     async exists(path) {
-      return await fs.exists(path) || await virtual(path) !== void 0;
+      return await fs.exists(path) || await linked(path) !== void 0;
     },
     stat: (path) => stat(path, (p) => fs.stat(p)),
     lstat: (path) => stat(path, (p) => fs.lstat(p)),
@@ -435,11 +813,31 @@ function withCommandDirs(fs, names) {
       const extra = await children(path);
       if (!extra) return fs.readdir(path);
       const real = await fs.readdir(path).catch((err) => {
-        if (missing(err)) return [];
+        if (missing2(err)) return [];
         throw err;
       });
       return [.../* @__PURE__ */ new Set([...real, ...extra])].sort();
     },
+    async readdirStat(path) {
+      const extra = await children(path);
+      if (!extra) return fs.readdirStat(path);
+      const real = await fs.readdirStat(path).catch((err) => {
+        if (missing2(err)) return [];
+        throw err;
+      });
+      const seen = new Set(real.map(([name]) => name));
+      const base = path === "/" ? "" : path;
+      const added = extra.filter((name) => !seen.has(name));
+      const virtuals = await Promise.all(
+        added.map(
+          async (name) => [
+            name,
+            await virtual(`${base}/${name}`)
+          ]
+        )
+      );
+      return [...real, ...virtuals].sort(([a], [b]) => a < b ? -1 : 1);
+    },
     mkdir: (path, options) => fs.mkdir(path, options),
     rm: (path, options) => fs.rm(path, options),
     rename: (from, to) => fs.rename(from, to),
@@ -1013,21 +1411,14 @@ function statJson(s) {
     isSymbolicLink: s.isSymbolicLink,
     size: s.size,
     mode: s.mode,
-    mtimeMs: s.mtime.getTime()
+    mtimeMs: s.mtime.getTime(),
+    atimeMs: s.atime.getTime(),
+    ctimeMs: s.ctime.getTime(),
+    ino: s.ino
   };
 }
 async function readdirStat(fs, dir) {
-  const names = await fs.readdir(dir);
-  const base = dir === "/" ? "" : dir;
-  return Promise.all(
-    names.map(async (name) => {
-      try {
-        return [name, statJson(await fs.lstat(`${base}/${name}`))];
-      } catch {
-        return [name, null];
-      }
-    })
-  );
+  return (await fs.readdirStat(dir)).map(([name, stat]) => [name, stat && statJson(stat)]);
 }
 var done = { ok: true, kind: "void" };
 function json(value) {
@@ -1168,7 +1559,7 @@ function attachSyncSabResponder(port, sab, token, opts) {
     Atomics.notify(header, SAB_I_STATE);
     if (offset + chunk >= entry.payload.byteLength) drop(id);
   }
-  function settle(id, result) {
+  function settle2(id, result) {
     if (disposed) return;
     const { status, payload } = encodeSabResult(result);
     drop(id);
@@ -1187,7 +1578,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) {
-        settle(data.id, { ok: false, errno: "EIO", message: "sync-sab: bad continuation" });
+        settle2(data.id, { ok: false, errno: "EIO", message: "sync-sab: bad continuation" });
         return;
       }
       publish(data.id, entry, offset);
@@ -1201,7 +1592,7 @@ function attachSyncSabResponder(port, sab, token, opts) {
     try {
       dispatched = dispatch(req);
     } catch (err) {
-      settle(id, {
+      settle2(id, {
         ok: false,
         errno: "EIO",
         message: err instanceof Error ? err.message : String(err)
@@ -1209,8 +1600,8 @@ function attachSyncSabResponder(port, sab, token, opts) {
       return;
     }
     void dispatched.then(
-      (result) => settle(id, result),
-      (err) => settle(id, {
+      (result) => settle2(id, result),
+      (err) => settle2(id, {
         ok: false,
         errno: "EIO",
         message: err instanceof Error ? err.message : String(err)
@@ -1888,15 +2279,15 @@ var VfsNodes = class {
   }
   renamed(from, to) {
     if (from === to) return;
-    const moved = [];
+    const moved2 = [];
     for (const [p, node] of this.byPath) {
-      if (within2(p, from)) moved.push(node);
+      if (within2(p, from)) moved2.push(node);
       else if (within2(p, to)) {
         node.orphaned = true;
         this.byPath.delete(p);
       }
     }
-    for (const node of moved) {
+    for (const node of moved2) {
       this.byPath.delete(node.path);
       node.path = to + node.path.slice(from.length);
       this.byPath.set(node.path, node);
@@ -2557,8 +2948,8 @@ function spawnWasmProcess(opts) {
     return dispatchSyncFs(req);
   };
   const responder = attachSyncSabResponder(worker, sab, token, { dispatch });
-  let settle;
-  const exited = new Promise((resolve) => settle = resolve);
+  let settle2;
+  const exited = new Promise((resolve) => settle2 = resolve);
   let done3 = false;
   let endedBy;
   const finish = (code, sig) => {
@@ -2571,8 +2962,8 @@ function spawnWasmProcess(opts) {
     revokeSyncFsToken(token);
     worker.terminate();
     void process.exit().then(
-      () => settle(code),
-      () => settle(code)
+      () => settle2(code),
+      () => settle2(code)
     );
   };
   const onMessage = (event) => {
@@ -2795,7 +3186,9 @@ var Launcher = class {
       const command = (await this.commands()).get(name);
       return command && targetOf(command);
     }
-    const glue = this.fs.resolvePath(cwd, file);
+    const glue = await followLinks(this.base, this.fs.resolvePath(cwd, file));
+    const linked = COMMAND2.exec(glue)?.[1];
+    if (linked !== void 0) return this.resolve(`/bin/${linked}`, argv0, cwd);
     const wasm = modulePath(glue);
     if (!await this.base.exists(glue) || !await this.base.exists(wasm)) return void 0;
     return { glue, wasm, argv0: baseName(argv0 || file) };
@@ -3033,8 +3426,12 @@ function serveKernel(port, deps) {
   async function handle(req) {
     if (req.op === "init") {
       launcher = (req.root ? Promise.resolve(req.root) : deps.storage()).then(async (root) => {
+        const name = req.metadata ?? META_DB;
+        const meta = name === false ? void 0 : await deps.metadata?.(name);
+        const fs = new OpfsFs(root, meta);
+        await fs.reconcile();
         const started = new Launcher({
-          fs: new OpfsFs(root),
+          fs,
           createWorker: deps.createWorker,
           ...req.modules ? { modules: req.modules } : {},
           ...req.env ? { env: req.env } : {}
@@ -3071,6 +3468,7 @@ function serveKernel(port, deps) {
 var processWorker = new URL("./process-worker.js", import.meta.url);
 serveKernel(globalThis, {
   storage: () => navigator.storage.getDirectory(),
-  createWorker: () => new Worker(processWorker, { type: "module" })
+  createWorker: () => new Worker(processWorker, { type: "module" }),
+  metadata: (name) => openMeta(name, indexedDB)
 });
 //# sourceMappingURL=kernel-worker.js.map