@ai-ecoverse/slicc-kernel 1.61.2 → 1.62.1

package/dist/kernel-worker.js

@@ -73,7 +73,7 @@ var IndexedDbMeta = class {
     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);
+      if (trees.some((tree2) => under(key, tree2))) this.cache.delete(key);
     }
   }
   changed(invalidation2) {
@@ -195,13 +195,13 @@ function fsError(code, path) {
   return Object.assign(new Error(`${code}: ${path}`), { code });
 }
 function normalizePath(path) {
-  const parts = [];
+  const parts2 = [];
   for (const part of path.split("/")) {
     if (part === "" || part === ".") continue;
-    if (part === "..") parts.pop();
-    else parts.push(part);
+    if (part === "..") parts2.pop();
+    else parts2.push(part);
   }
-  return `/${parts.join("/")}`;
+  return `/${parts2.join("/")}`;
 }
 function resolvePath(base, path) {
   return normalizePath(path.startsWith("/") ? path : `${base}/${path}`);
@@ -239,8 +239,8 @@ function inherit(entries) {
   return { ...ROOT_OWNER };
 }
 function chain(path) {
-  const parts = path.split("/").filter(Boolean);
-  return ["/", ...parts.map((_, i) => `/${parts.slice(0, i + 1).join("/")}`)];
+  const parts2 = path.split("/").filter(Boolean);
+  return ["/", ...parts2.map((_, i) => `/${parts2.slice(0, i + 1).join("/")}`)];
 }
 function sameOwner(a, b) {
   return a.uid === b.uid && a.gid === b.gid;
@@ -315,10 +315,10 @@ function translate(err, path, op = "lookup", mapped = true) {
 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) => {
+  const guarded2 = (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)]));
+  return Object.fromEntries(META_OPS.map((op) => [op, guarded2(op)]));
 }
 function missing(err) {
   const code = err?.code;
@@ -334,8 +334,8 @@ 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("/")}`);
+  const parts2 = split(path);
+  return parts2.map((_, i) => `/${parts2.slice(0, i + 1).join("/")}`);
 }
 function within(path, root) {
   return path === root || path.startsWith(`${root}/`);
@@ -356,39 +356,39 @@ async function openSync(handle) {
     }
   }
 }
-function writeAll(access, at, bytes) {
+function writeAll(access2, at, bytes) {
   for (let done4 = 0; done4 < bytes.length; ) {
-    const n = access.write(bytes.subarray(done4), { at: at + done4 });
+    const n = access2.write(bytes.subarray(done4), { at: at + done4 });
     if (!(n > 0))
       throw Object.assign(new Error("the file system took no more bytes"), { code: "ENOSPC" });
     done4 += n;
   }
 }
 async function positioned(handle, op) {
-  const access = await openSync(handle);
-  if (access) {
+  const access2 = await openSync(handle);
+  if (access2) {
     try {
       op({
-        write: (at, bytes) => writeAll(access, at, bytes),
-        truncate: (n) => access.truncate(n)
+        write: (at, bytes) => writeAll(access2, at, bytes),
+        truncate: (n) => access2.truncate(n)
       });
-      access.flush();
+      access2.flush();
     } finally {
-      access.close();
+      access2.close();
     }
     return;
   }
-  const writable = await handle.createWritable({ keepExistingData: true });
+  const writable2 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
-      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }),
-      truncate: (n) => writable.truncate(n)
+      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }),
+      truncate: (n) => writable2.truncate(n)
     });
   } catch (err) {
-    await writable.abort();
+    await writable2.abort();
     throw err;
   }
-  await writable.close();
+  await writable2.close();
 }
 function syncAccessHandles(scope = globalThis) {
   const handle = scope.FileSystemFileHandle;
@@ -427,6 +427,14 @@ var OpfsFs = class {
   trackOwners() {
     this.owners = true;
   }
+  async ancestry(path) {
+    const entries = await this.meta.get(chain(path));
+    return entries.map((entry, i) => ({
+      ...ownOf(entry) ?? (i === 0 ? ROOT_OWNER : inherit(entries.slice(0, i))),
+      ...entry?.mode !== void 0 ? { mode: entry.mode } : {},
+      ...entry?.link !== void 0 ? { link: entry.link } : {}
+    }));
+  }
   async handedTo(dir) {
     return inherit(await this.meta.get(chain(dir)));
   }
@@ -491,30 +499,30 @@ var OpfsFs = class {
     const [stored] = source.link ? [source.link] : await this.meta.get([source.path]);
     return ownOf(stored) ? void 0 : this.ownerAt(source.path, stored);
   }
-  async walk(parts, from, start2) {
+  async walk(parts2, from, start2) {
     let dir = start2;
-    for (let at = from; at < parts.length; at++) {
-      dir = await dir.getDirectoryHandle(parts[at]);
-      this.dirs.set(`/${parts.slice(0, at + 1).join("/")}`, dir);
+    for (let at = from; at < parts2.length; at++) {
+      dir = await dir.getDirectoryHandle(parts2[at]);
+      this.dirs.set(`/${parts2.slice(0, at + 1).join("/")}`, dir);
       this.checked.set(dir, performance.now());
     }
     return dir;
   }
   async dir(path) {
-    const parts = split(path);
-    let from = parts.length;
+    const parts2 = split(path);
+    let from = parts2.length;
     let cached;
     for (; from > 0 && !cached; from--)
-      cached = this.dirs.get(`/${parts.slice(0, from).join("/")}`);
+      cached = this.dirs.get(`/${parts2.slice(0, from).join("/")}`);
     if (cached) from++;
-    const at = `/${parts.slice(0, from).join("/")}`;
+    const at = `/${parts2.slice(0, from).join("/")}`;
     if (cached && !await this.current(at, cached)) {
       this.forget(at);
       cached = void 0;
       from = 0;
     }
     try {
-      return await this.walk(parts, from, cached ?? this.root);
+      return await this.walk(parts2, from, cached ?? this.root);
     } catch (err) {
       throw translate(err, path);
     }
@@ -544,10 +552,10 @@ var OpfsFs = class {
     return kind === "file" ? parent.getFileHandle(name2) : parent.getDirectoryHandle(name2);
   }
   async parent(path) {
-    const parts = split(path);
-    const name2 = parts.pop();
+    const parts2 = split(path);
+    const name2 = parts2.pop();
     if (name2 === void 0) throw fsError("EBUSY", path);
-    return [`/${parts.join("/")}`, name2];
+    return [`/${parts2.join("/")}`, name2];
   }
   async handle(path) {
     if (split(path).length === 0) return this.root;
@@ -749,19 +757,19 @@ var OpfsFs = class {
   }
   async writeSession(path, truncate) {
     const handle = (await this.fileFor(path))[0];
-    const writable = await this.retrying(
+    const writable2 = await this.retrying(
       path,
       () => handle.createWritable({ keepExistingData: !truncate }),
       true
     );
     return {
-      write: (at, bytes) => writable.write({ type: "write", position: at, data: bytes }).catch((err) => {
+      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      truncate: (size) => writable.truncate(size).catch((err) => {
+      truncate: (size) => writable2.truncate(size).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      close: () => writable.close().catch((err) => {
+      close: () => writable2.close().catch((err) => {
         throw translate(err, path, "commit", false);
       })
     };
@@ -799,9 +807,9 @@ var OpfsFs = class {
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
     try {
-      const writable = await file.createWritable();
-      await writable.write(content);
-      await writable.close();
+      const writable2 = await file.createWritable();
+      await writable2.write(content);
+      await writable2.close();
     } catch (err) {
       throw translate(err, path, "commit", false);
     }
@@ -987,9 +995,9 @@ var OpfsFs = class {
   }
   async copy(handle, dir, name2) {
     if (handle.kind === "file") {
-      const writable = await (await dir.getFileHandle(name2, { create: true })).createWritable();
-      await writable.write(await handle.getFile());
-      await writable.close();
+      const writable2 = await (await dir.getFileHandle(name2, { create: true })).createWritable();
+      await writable2.write(await handle.getFile());
+      await writable2.close();
       return;
     }
     const target = await dir.getDirectoryHandle(name2, { create: true });
@@ -1241,6 +1249,298 @@ function versionError(theirs) {
   return `slicc-kernel client protocol ${named} is not supported: this side speaks ${PROTOCOL.join(".")}`;
 }
 
+// src/fs/walk.ts
+var MAX_LINKS2 = 40;
+function parentOf3(path) {
+  return path.slice(0, path.lastIndexOf("/")) || "/";
+}
+async function mustBeDir(fs, path) {
+  if (!fs.lstat) return;
+  const st = await fs.lstat(path);
+  if (st.isDirectory !== true) throw fsError("ENOTDIR", path);
+}
+async function linkOf(fs, path) {
+  return fs.readlink?.(path).catch(() => void 0);
+}
+async function realDir(fs, dir, budget = { hops: 0 }) {
+  const queue = dir.split("/").filter(Boolean);
+  let at = "/";
+  while (queue.length > 0) {
+    const part = queue.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      at = parentOf3(at);
+      continue;
+    }
+    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
+    const link2 = await linkOf(fs, next2);
+    if (link2 === void 0) {
+      if (queue.find((p) => p !== ".") === "..") await mustBeDir(fs, next2);
+      at = next2;
+      continue;
+    }
+    if (budget.hops >= MAX_LINKS2) throw fsError("ELOOP", dir);
+    budget.hops++;
+    queue.unshift(...link2.split("/").filter(Boolean));
+    if (link2.startsWith("/")) at = "/";
+  }
+  return at;
+}
+function joinName(dir, name2) {
+  return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
+}
+async function realTarget(fs, path) {
+  const budget = { hops: 0 };
+  let dir = await realDir(fs, parentOf3(path), budget);
+  let name2 = path.slice(path.lastIndexOf("/") + 1);
+  for (; ; ) {
+    const link2 = await linkOf(fs, joinName(dir, name2));
+    if (link2 === void 0) break;
+    if (budget.hops >= MAX_LINKS2) throw fsError("ELOOP", path);
+    budget.hops++;
+    const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
+    dir = await realDir(fs, parentOf3(target), budget);
+    name2 = target.slice(target.lastIndexOf("/") + 1);
+  }
+  return joinName(dir, name2);
+}
+
+// src/fs/access.ts
+var R_OK = 4;
+var W_OK = 2;
+var X_OK = 1;
+var MAX_LINKS3 = 40;
+var S_ISVTX = 512;
+function permOf(st, link2) {
+  return {
+    uid: st.uid ?? 0,
+    gid: st.gid ?? 0,
+    mode: st.mode & 4095,
+    ...link2 !== void 0 ? { link: link2 } : {}
+  };
+}
+function permits(cred, perm, want, directory = true) {
+  const mode = perm.mode ?? (directory ? 493 : 420);
+  if (cred.euid === 0) return (want & X_OK) === 0 || directory || (mode & 73) !== 0;
+  const shift = cred.euid === perm.uid ? 6 : inGroup(cred, perm.gid) ? 3 : 0;
+  return (mode >> shift & want) === want;
+}
+function sticky(cred, dir, entry) {
+  if (cred.euid === 0 || ((dir.mode ?? 0) & S_ISVTX) === 0) return true;
+  return cred.euid === dir.uid || cred.euid === (entry ?? dir).uid;
+}
+async function ancestryOf(fs, path) {
+  if (fs.ancestry) return fs.ancestry(path);
+  const out = [];
+  for (const at of chain(path)) {
+    const st = await fs.lstat(at).catch(() => void 0);
+    if (!st) break;
+    out.push(permOf(st, st.isSymbolicLink ? await fs.readlink(at) : void 0));
+  }
+  return out;
+}
+var Perms = class {
+  known = /* @__PURE__ */ new Map();
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async learn(path) {
+    const names = chain(path);
+    const perms = await ancestryOf(this.fs, path);
+    for (let i = 0; i < names.length; i++) {
+      const perm = perms[i];
+      this.known.set(names[i], perm);
+      if (perm === void 0 || perm.link !== void 0) break;
+    }
+  }
+  async at(path) {
+    if (!this.known.has(path)) await this.learn(path);
+    return this.known.get(path);
+  }
+};
+function parts(path) {
+  return path.split("/").filter((part) => part !== "" && part !== ".");
+}
+async function walk(fs, cred, path, follow2) {
+  const perms = new Perms(fs);
+  await perms.learn(path);
+  const queue = parts(path);
+  let at = "/";
+  for (let hops = 0; queue.length > 0; ) {
+    const part = queue.shift();
+    const dir = await perms.at(at);
+    if (!dir) return { path: joinName(at, [part, ...queue].join("/")), perm: void 0 };
+    if (!permits(cred, dir, X_OK)) return { path, perm: void 0, denied: at };
+    if (part === "..") {
+      at = parentOf3(at);
+      continue;
+    }
+    const next2 = joinName(at, part);
+    const perm = await perms.at(next2);
+    const last = queue.length === 0;
+    if (perm?.link !== void 0 && (!last || follow2)) {
+      if (++hops > MAX_LINKS3) return { path: next2, perm: void 0 };
+      queue.unshift(...parts(perm.link));
+      if (perm.link.startsWith("/")) at = "/";
+      continue;
+    }
+    if (last) return { path: next2, perm };
+    at = next2;
+  }
+  return { path: at, perm: await perms.at(at) };
+}
+async function present(fs, path, directory) {
+  const st = await fs.lstat(path).catch(() => void 0);
+  return st !== void 0 && (!directory || st.isDirectory);
+}
+async function access(fs, cred, path, want, options = {}) {
+  const walked = await walk(fs, cred, path, options.follow !== false);
+  if (walked.denied !== void 0) {
+    if (await present(fs, walked.denied, true)) return walked;
+    return { path, perm: void 0, missing: true };
+  }
+  const { perm } = walked;
+  if (!perm) return { ...walked, missing: true };
+  if (want === 0 || permits(cred, perm, want, options.directory !== false)) return walked;
+  if (await present(fs, walked.path, false)) return { ...walked, denied: walked.path };
+  return { ...walked, missing: true };
+}
+function refused(path, errno = "EACCES") {
+  return fsError(errno, path);
+}
+
+// src/fs/dac.ts
+var MAX_DENIAL_KEYS = 1e4;
+var S_ISGID3 = 1024;
+var Dac = class {
+  mode;
+  hook;
+  log;
+  seen = /* @__PURE__ */ new Set();
+  suppressed = false;
+  constructor(mode, hook, log = (line) => console.warn(line)) {
+    this.mode = mode;
+    this.hook = hook;
+    this.log = log;
+  }
+  get enforcing() {
+    return this.mode === "enforce";
+  }
+  denied(denial) {
+    try {
+      this.hook?.({ ...denial });
+    } catch {
+    }
+    if (this.mode === "report") this.note(denial);
+    else throw refused(denial.path, denial.errno);
+  }
+  note(d) {
+    const key = `${d.uid}\0${d.op}\0${d.errno}\0${d.path}`;
+    if (this.seen.has(key)) return;
+    if (this.seen.size >= MAX_DENIAL_KEYS) {
+      if (!this.suppressed) this.log("slicc-kernel users report: more denials suppressed");
+      this.suppressed = true;
+      return;
+    }
+    this.seen.add(key);
+    this.log(
+      `slicc-kernel users report: ${d.errno} ${d.op} ${d.path} (uid ${d.uid}, pid ${d.pid})`
+    );
+  }
+};
+function deny(g, op, path, errno = "EACCES") {
+  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno });
+}
+async function need(g, op, path, want, options = {}, shown = path) {
+  const walked = await access(g.fs, g.cred, path, want, options);
+  if (walked.denied !== void 0) deny(g, op, shown);
+  return walked;
+}
+async function stickyEntry(g, op, path, dir) {
+  const perm = dir.perm;
+  if (!perm || sticky(g.cred, perm, perm)) return;
+  const entry = joinName(dir.path, path.slice(path.lastIndexOf("/") + 1));
+  if (sticky(g.cred, perm, (await ancestryOf(g.fs, entry)).at(-1))) return;
+  if (await present(g.fs, entry, false)) deny(g, op, path, "EPERM");
+}
+async function inParent(g, op, path, old = false) {
+  const dir = await need(g, op, parentOf3(path), W_OK | X_OK, {}, path);
+  if (old && dir.denied === void 0) await stickyEntry(g, op, path, dir);
+}
+async function makeIn(g, op, path) {
+  for (let dir = parentOf3(path); ; dir = parentOf3(dir)) {
+    const walked = await access(g.fs, g.cred, dir, W_OK | X_OK);
+    if (walked.denied !== void 0) {
+      if (!await present(g.fs, path, true)) deny(g, op, path);
+      return;
+    }
+    if (!walked.missing || dir === "/") return;
+  }
+}
+async function tree(g, op, dir, perm) {
+  if (!permits(g.cred, perm, R_OK | W_OK | X_OK)) return deny(g, op, dir);
+  for (const [name2, st] of await g.fs.readdirStat(dir)) {
+    if (!st) continue;
+    const child = joinName(dir, name2);
+    if (!sticky(g.cred, perm, permOf(st))) deny(g, op, child, "EPERM");
+    if (st.isDirectory) await tree(g, op, child, permOf(st));
+  }
+}
+async function removable(g, op, path) {
+  await inParent(g, op, path, true);
+  if (g.cred.euid === 0) return;
+  const st = await g.fs.lstat(path).catch(() => void 0);
+  if (st?.isDirectory) await tree(g, op, path, permOf(st));
+}
+async function renamable(g, from, to) {
+  if (from === to) return void await need(g, "rename", from, 0, { follow: false });
+  await inParent(g, "rename", from, true);
+  await inParent(g, "rename", to, true);
+  if (g.cred.euid === 0 || parentOf3(from) === parentOf3(to)) return;
+  const st = await g.fs.lstat(from).catch(() => void 0);
+  if (st?.isDirectory && !permits(g.cred, permOf(st), W_OK)) deny(g, "rename", from);
+}
+async function linkable(g, from, to, follow2) {
+  const source = await need(g, "link", from, 0, { follow: follow2 });
+  const perm = source.perm;
+  if (perm && g.cred.euid !== 0 && perm.uid !== g.cred.euid) {
+    const safe = permits(g.cred, perm, R_OK | W_OK, false);
+    if (!safe && await present(g.fs, source.path, false)) deny(g, "link", from, "EPERM");
+  }
+  await inParent(g, "link", to);
+}
+async function ownerOnly(g, op, path, follow2) {
+  const walked = await need(g, op, path, 0, { follow: follow2 });
+  const perm = walked.perm;
+  if (!perm || g.cred.euid === 0 || perm.uid === g.cred.euid) return walked;
+  if (await present(g.fs, walked.path, false)) deny(g, op, path, "EPERM");
+  return walked;
+}
+async function chmodMode(g, path, mode) {
+  const perm = (await ownerOnly(g, "chmod", path, true)).perm;
+  if (!g.dac.enforcing || !perm || g.cred.euid === 0 || inGroup(g.cred, perm.gid)) return mode;
+  return mode & ~S_ISGID3;
+}
+async function retimable(g, op, path) {
+  await ownerOnly(g, op, path, op !== "lutimes");
+}
+async function listable(g, op, path) {
+  await need(g, op, path, R_OK | X_OK, { directory: true });
+}
+async function searchable(g, op, path, follow2) {
+  await need(g, op, path, 0, { follow: follow2 });
+}
+async function readable(g, op, path) {
+  await need(g, op, path, R_OK, { directory: false });
+}
+async function writable(g, op, path) {
+  const st = await g.fs.stat(path).catch(() => void 0);
+  if (st) return void await need(g, op, path, W_OK, { directory: st.isDirectory });
+  const target = await need(g, op, path, 0);
+  if (target.denied === void 0) await need(g, op, parentOf3(target.path), W_OK | X_OK, {}, path);
+}
+
 // src/kernel/pipe.ts
 var PIPE_CAPACITY = 64 * 1024;
 var PipeError = class extends Error {
@@ -1484,7 +1784,7 @@ function written(device, bytes) {
   if (device === "full" && bytes.length > 0) throw new KernelError("ENOSPC");
   return bytes.length;
 }
-function deviceFile(device, access) {
+function deviceFile(device, access2) {
   const read = async (max) => {
     if (device === "null") return new Uint8Array(0);
     const out = new Uint8Array(max);
@@ -1496,10 +1796,10 @@ function deviceFile(device, access) {
     return out;
   };
   return new OpenFile({
-    ...access !== "write" ? { read } : {},
-    ...access !== "read" ? { write: async (bytes) => written(device, bytes) } : {},
+    ...access2 !== "write" ? { read } : {},
+    ...access2 !== "read" ? { write: async (bytes) => written(device, bytes) } : {},
     seek: async () => 0,
-    heldMeta: { device, ...access ? { access } : {} },
+    heldMeta: { device, ...access2 ? { access: access2 } : {} },
     close: () => {
     }
   });
@@ -2751,9 +3051,9 @@ var UserDb = class {
     if (await this.realDir(pnpm)) await this.fs.chmod(pnpm, scoop ? 488 : 448);
   }
   async realDir(path) {
-    const parts = path.split("/").filter(Boolean);
-    for (let n = 1; n <= parts.length; n++) {
-      const at = `/${parts.slice(0, n).join("/")}`;
+    const parts2 = path.split("/").filter(Boolean);
+    for (let n = 1; n <= parts2.length; n++) {
+      const at = `/${parts2.slice(0, n).join("/")}`;
       const st = await this.fs.lstat(at).catch(() => void 0);
       if (!st?.isDirectory) return false;
     }
@@ -2954,7 +3254,7 @@ var UserDb = class {
 };
 
 // src/client/serve-client.ts
-var MAX_LINKS2 = 40;
+var MAX_LINKS4 = 40;
 function act(session, req, signal) {
   if (req.action === "write") session.write(req.bytes);
   else if (req.action === "resize") session.resize(req.cols, req.rows);
@@ -2962,26 +3262,50 @@ function act(session, req, signal) {
   else session.close();
 }
 async function realpath(fs, path) {
-  let parts = fs.resolvePath("/", path).split("/").filter(Boolean);
+  let parts2 = fs.resolvePath("/", path).split("/").filter(Boolean);
   let resolved = "";
-  for (let hops = 0; parts.length > 0; ) {
-    const [name2, ...rest2] = parts;
+  for (let hops = 0; parts2.length > 0; ) {
+    const [name2, ...rest2] = parts2;
     const next2 = `${resolved}/${name2}`;
     if (!(await fs.lstat(next2)).isSymbolicLink) {
       resolved = next2;
-      parts = rest2;
+      parts2 = rest2;
       continue;
     }
-    if (++hops > MAX_LINKS2) throw fsError("ELOOP", path);
+    if (++hops > MAX_LINKS4) throw fsError("ELOOP", path);
     const target = await fs.readlink(next2);
     const base = target.startsWith("/") ? "/" : resolved || "/";
-    parts = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest2];
+    parts2 = [...fs.resolvePath(base, target).split("/").filter(Boolean), ...rest2];
     resolved = "";
   }
   return resolved || "/";
 }
-async function fsCall(fs, method, args, owner) {
+var CLIENT_CHECKS = {
+  readFile: (g, at) => readable(g, "read", at(0)),
+  writeFile: (g, at) => writable(g, "write", at(0)),
+  stat: (g, at) => searchable(g, "stat", at(0), true),
+  lstat: (g, at) => searchable(g, "lstat", at(0), false),
+  readdir: (g, at) => listable(g, "readdir", at(0)),
+  mkdir: (g, at) => makeIn(g, "mkdir", at(0)),
+  rm: (g, at) => removable(g, "rm", at(0)),
+  rename: (g, at) => renamable(g, at(0), at(1)),
+  realpath: (g, at) => searchable(g, "realpath", at(0), true),
+  symlink: (g, at) => inParent(g, "symlink", at(1)),
+  readlink: (g, at) => searchable(g, "readlink", at(0), false),
+  exists: (g, at) => searchable(g, "exists", at(0), true)
+};
+async function fsCall(fs, method, args, owner, g) {
   const path = (i) => fs.resolvePath("/", String(args[i]));
+  if (g) {
+    const denied2 = await Promise.resolve(CLIENT_CHECKS[method](g, path)).then(
+      () => false,
+      (err) => {
+        if (method === "exists") return true;
+        throw err;
+      }
+    );
+    if (denied2) return { result: false };
+  }
   switch (method) {
     case "readFile": {
       const bytes = (await fs.readFileBuffer(path(0))).slice();
@@ -3044,6 +3368,10 @@ function ownerFor(l, self) {
   if (!l.owners || !self) return void 0;
   return { uid: self.uid, gid: self.gid, umask: self.umask ?? 18 };
 }
+function guardFor(l, self) {
+  if (!l.dac || !self) return void 0;
+  return { fs: l.fs, cred: credOf(self), pid: 0, dac: l.dac };
+}
 async function accountOf(l, user) {
   const found = await l.users.lookup(user);
   if (!found) throw fsError("ENOENT", `no user ${String(user)}`);
@@ -3112,17 +3440,28 @@ function cdpRegistry(send, gone) {
     }
   };
 }
-function watchOp(l, req, watches, send) {
+function visibleTo(g, notify) {
+  if (!g?.dac.enforcing) return notify;
+  let queue = Promise.resolve();
+  const seen = async (path) => (await access(g.fs, g.cred, parentOf3(path), R_OK | X_OK, { directory: true })).denied === void 0;
+  return (change) => {
+    queue = queue.then(async () => {
+      if (!("paths" in change)) return notify(change);
+      const paths = [];
+      for (const path of change.paths) if (await seen(path)) paths.push(path);
+      if (paths.length > 0) notify({ paths });
+    });
+  };
+}
+async function watchOp(l, req, watches, send, g) {
   if (req.op === "unwatch") {
     watches.get(req.watch)?.();
     watches.delete(req.watch);
     return { result: true };
   }
-  const unwatch = l.watchers.watch(
-    req.paths,
-    { recursive: req.recursive },
-    (change) => send({ watch: req.id, change })
-  );
+  if (g) for (const path of req.paths) await readable(g, "watch", l.fs.resolvePath("/", path));
+  const notify = visibleTo(g, (change) => send({ watch: req.id, change }));
+  const unwatch = l.watchers.watch(req.paths, { recursive: req.recursive }, notify);
   watches.set(req.id, unwatch);
   return { result: req.id };
 }
@@ -3156,9 +3495,9 @@ function serveClient(port, host) {
     ended.resolve();
   }
   async function hello(message3) {
-    const refused = versionError(message3.protocol);
-    if (refused) {
-      send({ hello: { protocol: PROTOCOL, error: refused } });
+    const refused2 = versionError(message3.protocol);
+    if (refused2) {
+      send({ hello: { protocol: PROTOCOL, error: refused2 } });
       detach();
       return;
     }
@@ -3238,10 +3577,10 @@ function serveClient(port, host) {
         if (!FS_METHODS.includes(req.method)) {
           throw new Error(`unknown file system call ${req.method}`);
         }
-        return fsCall(l.fs, req.method, req.args, ownerFor(l, self));
+        return fsCall(l.fs, req.method, req.args, ownerFor(l, self), guardFor(l, self));
       case "watch":
       case "unwatch":
-        return watchOp(l, req, watches, send);
+        return watchOp(l, req, watches, send, guardFor(l, self));
       case "mount":
         return { result: await l.mount(req.spec) };
       case "umount":
@@ -4184,8 +4523,8 @@ var RealmProxy = class {
   }
   async connect(conn, incoming, req, idle) {
     const target = tunnelTarget(req);
-    const refused = target.port === 443 ? await this.tunnelReady(target) : void 0;
-    if (refused) throw refused;
+    const refused2 = target.port === 443 ? await this.tunnelReady(target) : void 0;
+    if (refused2) throw refused2;
     await conn.write(latin1Bytes("HTTP/1.1 200 Connection Established\r\n\r\n"), this.stop.signal);
     try {
       const first = await incoming.peek(this.stop.signal);
@@ -4328,10 +4667,10 @@ var RealmProxy = class {
 };
 
 // src/kernel/net/x509.ts
-function concat2(parts) {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+function concat2(parts2) {
+  const out = new Uint8Array(parts2.reduce((n, p) => n + p.length, 0));
   let at = 0;
-  for (const p of parts) {
+  for (const p of parts2) {
     out.set(p, at);
     at += p.length;
   }
@@ -4347,8 +4686,8 @@ function tlv(tag, ...contents2) {
   const body = concat2(contents2);
   return concat2([Uint8Array.of(tag), length(body.length), body]);
 }
-var seq = (...parts) => tlv(48, ...parts);
-var set = (...parts) => tlv(49, ...parts);
+var seq = (...parts2) => tlv(48, ...parts2);
+var set = (...parts2) => tlv(49, ...parts2);
 var octets = (bytes) => tlv(4, bytes);
 var bits = (bytes, unused = 0) => tlv(3, Uint8Array.of(unused), bytes);
 var TRUE = tlv(1, Uint8Array.of(255));
@@ -4436,8 +4775,8 @@ function randomSerial() {
 function ipv4(host) {
   const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
   if (!m) return void 0;
-  const parts = m.slice(1).map(Number);
-  return parts.every((p) => p <= 255) ? Uint8Array.from(parts) : void 0;
+  const parts2 = m.slice(1).map(Number);
+  return parts2.every((p) => p <= 255) ? Uint8Array.from(parts2) : void 0;
 }
 function ipv6(host) {
   if (!host.includes(":") || !/^[0-9A-Fa-f:.]+$/.test(host)) return void 0;
@@ -5211,9 +5550,9 @@ var RemoteTransport = class {
 // src/kernel/net/routes.ts
 var HOST_ADDRESS = HOST_LOOPBACK_ADDRESS.join(".");
 function ipv4Bytes(text) {
-  const parts = text.split(".");
-  if (parts.length !== 4 || !parts.every((p) => /^\d{1,3}$/.test(p))) return void 0;
-  const bytes = parts.map(Number);
+  const parts2 = text.split(".");
+  if (parts2.length !== 4 || !parts2.every((p) => /^\d{1,3}$/.test(p))) return void 0;
+  const bytes = parts2.map(Number);
   return bytes.every((b) => b <= 255) ? bytes : void 0;
 }
 function ipv6Groups(text) {
@@ -5240,9 +5579,9 @@ function addressBits(host) {
   return v6 ? { v6: true, bits: toBits(v6, 16) } : void 0;
 }
 function parsePrefix(text) {
-  const parts = text.trim().split("/");
-  if (parts.length > 2) return void 0;
-  const [address = "", size] = parts;
+  const parts2 = text.trim().split("/");
+  if (parts2.length > 2) return void 0;
+  const [address = "", size] = parts2;
   const parsed2 = addressBits(address);
   if (!parsed2) return void 0;
   const max = parsed2.v6 ? 128 : 32;
@@ -5903,7 +6242,7 @@ function binfmtOf(binfmts, path) {
 var S_IFDIR2 = 16384;
 var S_IFREG2 = 32768;
 var COMMAND = /^\/(?:usr\/)?bin\/([^/]+)$/;
-var MAX_LINKS3 = 40;
+var MAX_LINKS5 = 40;
 function missing2(err) {
   return err?.code === "ENOENT";
 }
@@ -5923,7 +6262,7 @@ function synthetic(directory, path) {
 }
 async function followLinks(fs, path) {
   let current = path;
-  for (let hops = 0; hops < MAX_LINKS3; hops++) {
+  for (let hops = 0; hops < MAX_LINKS5; hops++) {
     const st = await fs.lstat(current).catch(() => void 0);
     if (!st?.isSymbolicLink) return current;
     const parent = current.slice(0, current.lastIndexOf("/")) || "/";
@@ -6030,6 +6369,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     readlink: (path) => fs.readlink(path),
     ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
+    ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
     utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime),
     lutimes: (path, atime, mtime) => lutimesOf(fs, path, atime, mtime),
@@ -6042,12 +6382,12 @@ var MAX_HOPS = 40;
 function start(path) {
   return { done: [], todo: path.split("/").filter((p) => p !== ""), hops: 0 };
 }
-function next(walk) {
-  while (walk.todo.length > 0) {
-    const part = walk.todo.shift();
+function next(walk2) {
+  while (walk2.todo.length > 0) {
+    const part = walk2.todo.shift();
     if (part === ".") continue;
     if (part === "..") {
-      walk.done.pop();
+      walk2.done.pop();
       continue;
     }
     return part;
@@ -6055,33 +6395,33 @@ function next(walk) {
   return void 0;
 }
 function lexical(path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) walk.done.push(part);
-  return `/${walk.done.join("/")}`;
+  const walk2 = start(path);
+  for (let part = next(walk2); part !== void 0; part = next(walk2)) walk2.done.push(part);
+  return `/${walk2.done.join("/")}`;
 }
-function rest(walk, part) {
-  return lexical(`/${[...walk.done, part, ...walk.todo].join("/")}`);
+function rest(walk2, part) {
+  return lexical(`/${[...walk2.done, part, ...walk2.todo].join("/")}`);
 }
-function follow(walk, target) {
-  if (++walk.hops > MAX_HOPS) return false;
-  if (target.startsWith("/")) walk.done.length = 0;
-  walk.todo = [...target.split("/").filter((p) => p !== ""), ...walk.todo];
+function follow(walk2, target) {
+  if (++walk2.hops > MAX_HOPS) return false;
+  if (target.startsWith("/")) walk2.done.length = 0;
+  walk2.todo = [...target.split("/").filter((p) => p !== ""), ...walk2.todo];
   return true;
 }
 async function physicalPathAsync(fs, path) {
-  const walk = start(path);
-  for (let part = next(walk); part !== void 0; part = next(walk)) {
-    const at = `/${[...walk.done, part].join("/")}`;
+  const walk2 = start(path);
+  for (let part = next(walk2); part !== void 0; part = next(walk2)) {
+    const at = `/${[...walk2.done, part].join("/")}`;
     let target;
     try {
       target = (await fs.lstat(at)).isSymbolicLink ? await fs.readlink(at) : void 0;
     } catch {
-      return rest(walk, part);
+      return rest(walk2, part);
     }
-    if (target === void 0) walk.done.push(part);
-    else if (!follow(walk, target)) return lexical(path);
+    if (target === void 0) walk2.done.push(part);
+    else if (!follow(walk2, target)) return lexical(path);
   }
-  return `/${walk.done.join("/")}`;
+  return `/${walk2.done.join("/")}`;
 }
 
 // src/fs/unlinked.ts
@@ -6090,7 +6430,7 @@ function webLocks() {
   return globalThis.navigator?.locks;
 }
 var within3 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
-var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf4 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
 var PathGate = class {
@@ -6221,7 +6561,7 @@ var UnlinkedKeeper = class {
           await this.serial(async () => {
             await Promise.allSettled([this.fs.rename(file.hidden, path)]);
             this.unlinkedName(file.hidden);
-            await this.tidy(parentOf3(file.hidden));
+            await this.tidy(parentOf4(file.hidden));
           });
         }
         done4();
@@ -6261,7 +6601,7 @@ var UnlinkedKeeper = class {
     }
     await this.fs.rm(hidden).catch(() => void 0);
     this.unlinkedName(hidden);
-    await this.tidy(parentOf3(hidden));
+    await this.tidy(parentOf4(hidden));
   }
   async linkedName(hidden) {
     if (!mayLink(this.fs, hidden)) return;
@@ -6306,10 +6646,10 @@ var UnlinkedKeeper = class {
 // src/fs/watch.ts
 var WATCH_BATCH_LIMIT = 1e3;
 var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
-var parentOf4 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 function touches(watcher, changed) {
   return watcher.paths.some(
-    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf4(changed) === watched)
+    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf5(changed) === watched)
   );
 }
 var FsWatchers = class {
@@ -6358,9 +6698,9 @@ var FsWatchers = class {
       mkdir: async (path, options) => {
         const created3 = [];
         if (options?.recursive) {
-          const parts = normalizePath(path).split("/").filter(Boolean);
-          for (let at = 1; at < parts.length; at++) {
-            const ancestor = `/${parts.slice(0, at).join("/")}`;
+          const parts2 = normalizePath(path).split("/").filter(Boolean);
+          for (let at = 1; at < parts2.length; at++) {
+            const ancestor = `/${parts2.slice(0, at).join("/")}`;
             if (created3.length > 0 || !await fs.exists(ancestor)) created3.push(ancestor);
           }
         }
@@ -6589,62 +6929,6 @@ var ChildTable = class {
   }
 };
 
-// src/fs/walk.ts
-var MAX_LINKS4 = 40;
-function parentOf5(path) {
-  return path.slice(0, path.lastIndexOf("/")) || "/";
-}
-async function mustBeDir(fs, path) {
-  if (!fs.lstat) return;
-  const st = await fs.lstat(path);
-  if (st.isDirectory !== true) throw fsError("ENOTDIR", path);
-}
-async function linkOf(fs, path) {
-  return fs.readlink?.(path).catch(() => void 0);
-}
-async function realDir(fs, dir, budget = { hops: 0 }) {
-  const queue = dir.split("/").filter(Boolean);
-  let at = "/";
-  while (queue.length > 0) {
-    const part = queue.shift();
-    if (part === ".") continue;
-    if (part === "..") {
-      at = parentOf5(at);
-      continue;
-    }
-    const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
-    const link2 = await linkOf(fs, next2);
-    if (link2 === void 0) {
-      if (queue.find((p) => p !== ".") === "..") await mustBeDir(fs, next2);
-      at = next2;
-      continue;
-    }
-    if (budget.hops >= MAX_LINKS4) throw fsError("ELOOP", dir);
-    budget.hops++;
-    queue.unshift(...link2.split("/").filter(Boolean));
-    if (link2.startsWith("/")) at = "/";
-  }
-  return at;
-}
-function joinName(dir, name2) {
-  return dir === "/" ? `/${name2}` : `${dir}/${name2}`;
-}
-async function realTarget(fs, path) {
-  const budget = { hops: 0 };
-  let dir = await realDir(fs, parentOf5(path), budget);
-  let name2 = path.slice(path.lastIndexOf("/") + 1);
-  for (; ; ) {
-    const link2 = await linkOf(fs, joinName(dir, name2));
-    if (link2 === void 0) break;
-    if (budget.hops >= MAX_LINKS4) throw fsError("ELOOP", path);
-    budget.hops++;
-    const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
-    dir = await realDir(fs, parentOf5(target), budget);
-    name2 = target.slice(target.lastIndexOf("/") + 1);
-  }
-  return joinName(dir, name2);
-}
-
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 2];
 function driverVersionError(theirs) {
@@ -6707,8 +6991,8 @@ var DriverConnection = class _DriverConnection {
     } finally {
       clearTimeout(timer);
     }
-    const refused = driverVersionError(hello.protocol);
-    if (refused) throw errnoError("EPROTO", refused);
+    const refused2 = driverVersionError(hello.protocol);
+    if (refused2) throw errnoError("EPROTO", refused2);
     if (hello.error) throw errnoError(hello.errno ?? "EIO", hello.error);
     return new _DriverConnection(port, hello.capabilities ?? {}, waiting, timeoutMs, options.onFail);
   }
@@ -6748,7 +7032,7 @@ var DriverConnection = class _DriverConnection {
 };
 
 // src/mount/mount-fs.ts
-var S_ISGID3 = 1024;
+var S_ISGID4 = 1024;
 var ID = /^\d{1,10}$/;
 var MAX_ID2 = 4294967294;
 function idOption(value) {
@@ -6761,7 +7045,7 @@ function checkIds(options) {
     if (!ID.test(value) || Number(value) > MAX_ID2) throw errnoError("EINVAL", `${key}=${value}`);
   }
 }
-var MAX_LINKS5 = 40;
+var MAX_LINKS6 = 40;
 var STALE_RETRIES = 3;
 var SETTLE_ROUNDS = 4;
 var DEFAULT_IO = 8 * 1024 * 1024;
@@ -6999,12 +7283,12 @@ var MountTable = class {
   }
   list() {
     const mounted = [...this.mounts.values()].map(
-      ({ type, source, target, options, state, error, present: present2 }) => ({
+      ({ type, source, target, options, state, error, present: present3 }) => ({
         type,
         source,
         target,
         options: { ...options },
-        state: state === "ok" && present2?.() === false ? "nomedium" : state,
+        state: state === "ok" && present3?.() === false ? "nomedium" : state,
         ...error ? { error } : {}
       })
     );
@@ -7279,7 +7563,7 @@ var MountFs = class {
       throw err;
     }
     if (attr2.kind !== "symlink") return real;
-    if (hops >= MAX_LINKS5) throw errnoError("ELOOP", path);
+    if (hops >= MAX_LINKS6) throw errnoError("ELOOP", path);
     const target = await found.mount.conn.call({ op: "readlink", path: found.rel });
     return this.follow(this.base.resolvePath(parentOf6(real), target), hops + 1, create);
   }
@@ -7299,9 +7583,9 @@ var MountFs = class {
     if (!owner || !mount.owners || !mount.caps.owners) return void 0;
     const dir = parentOf6(real);
     const above = statOf(await this.table.getattr(mount, dir, parentOf6(rel2)), dir, mount);
-    const setgid = (above.mode & S_ISGID3) !== 0;
+    const setgid = (above.mode & S_ISGID4) !== 0;
     let mode = owner.mode;
-    if (directory && setgid) mode = (mode ?? 493) | S_ISGID3;
+    if (directory && setgid) mode = (mode ?? 493) | S_ISGID4;
     return {
       uid: owner.uid,
       gid: setgid ? above.gid : owner.gid,
@@ -7576,14 +7860,14 @@ var MountFs = class {
       await mount.conn.call({ op: "mkdir", path: rel2, ...made2 });
       return;
     }
-    const parts = rel2.split("/").filter(Boolean);
-    for (let n = 1; n <= parts.length; n++) {
-      const sub = `/${parts.slice(0, n).join("/")}`;
+    const parts2 = rel2.split("/").filter(Boolean);
+    for (let n = 1; n <= parts2.length; n++) {
+      const sub = `/${parts2.slice(0, n).join("/")}`;
       const full = normalizePath(`${mount.target}${sub}`);
       const exists = await this.table.getattr(mount, full, sub).catch(() => void 0);
       if (exists?.kind === "directory") continue;
       if (exists) throw errnoError("ENOTDIR", full);
-      const own = n === parts.length ? owner : owner && { ...owner, mode: owner.parents };
+      const own = n === parts2.length ? owner : owner && { ...owner, mode: owner.parents };
       const made2 = await this.driverOwner({ mount, rel: sub }, full, own, true);
       this.table.forget(mount, full);
       await mount.conn.call({ op: "mkdir", path: sub, ...made2 });
@@ -7676,6 +7960,20 @@ var MountFs = class {
     if (this.at(real)) throw errnoError("ENOSYS", path);
     return real;
   }
+  async ancestry(path) {
+    const names = chain(normalizePath(path));
+    const first = names.findIndex((name2) => this.at(name2));
+    if (first < 0) return ancestryOf(this.base, path);
+    const out = first === 0 ? [] : await ancestryOf(this.base, names[first - 1]);
+    if (out.length < first || out.some((perm) => perm?.link !== void 0)) return out;
+    for (const name2 of names.slice(first)) {
+      const st = await this.lstat(name2).catch(() => void 0);
+      if (!st) break;
+      out.push(permOf(st, st.isSymbolicLink ? await this.readlink(name2) : void 0));
+      if (st.isSymbolicLink) break;
+    }
+    return out;
+  }
   async readlink(path) {
     const found = this.at(path);
     if (!found) return this.base.readlink(path);
@@ -7886,9 +8184,11 @@ async function run(entry, path, req) {
       return done;
     case "readlink":
       return json2(await fs.readlink(path));
-    case "chmod":
-      await fs.chmod(path, req.mode ?? 0);
+    case "chmod": {
+      const g = guardOf(entry);
+      await fs.chmod(path, g ? await chmodMode(g, path, req.mode ?? 0) : req.mode ?? 0);
       return done;
+    }
     case "utimes":
       await fs.utimes(path, new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0));
       return done;
@@ -7906,6 +8206,53 @@ async function run(entry, path, req) {
       return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
   }
 }
+function guardOf(entry) {
+  const cred = entry.dac && entry.cred?.();
+  if (!cred || !entry.dac) return void 0;
+  return { fs: entry.fs, cred, pid: entry.pid ?? 0, dac: entry.dac };
+}
+var FOLLOWING = /* @__PURE__ */ new Set(["exists", "stat", "chown", "statfs"]);
+var NOT_FOLLOWING = /* @__PURE__ */ new Set(["lstat", "readlink", "lchown"]);
+async function guard(g, path, req, cwd) {
+  const { op } = req;
+  if (FOLLOWING.has(op) || NOT_FOLLOWING.has(op)) return searchable(g, op, path, FOLLOWING.has(op));
+  const other = () => g.fs.resolvePath(cwd, req.arg2 ?? "");
+  switch (op) {
+    case "readdir":
+    case "readdir-stat":
+      return listable(g, op, path);
+    case "mkdir":
+      return makeIn(g, op, path);
+    case "create":
+    case "symlink":
+      return inParent(g, op, path);
+    case "unlink":
+    case "rmdir":
+      return inParent(g, op, path, true);
+    case "rm":
+      return removable(g, op, path);
+    case "rename":
+      return renamable(g, path, other());
+    case "link":
+      return linkable(g, path, other(), req.mode === 1);
+    case "utimes":
+    case "lutimes":
+      return retimable(g, op, path);
+    default:
+      return void 0;
+  }
+}
+async function guarded(entry, path, req) {
+  const g = guardOf(entry);
+  if (!g) return void 0;
+  try {
+    await guard(g, path, req, entry.cwd);
+    return void 0;
+  } catch (err) {
+    const refusal = err.code === "EACCES";
+    return req.op === "exists" && refusal ? json2(false) : toErrno(err);
+  }
+}
 async function createExclusive(fs, path, owner) {
   if (fs.createExclusive) return fs.createExclusive(path, owner);
   if (await fs.lstat(path).then(
@@ -7958,24 +8305,56 @@ async function owned(entry, own, req, path, target) {
   }
   return own(target, () => run(entry, path, req));
 }
+async function holdOp(entry, path, req) {
+  const mode = req.mode ?? 0;
+  const [on, open] = [(mode & 1) === 1, (mode & 2) === 2];
+  if (on && open) {
+    const real = await entry.fs.realpath?.(path, true).catch(() => path);
+    return json2(entry.hold?.(path, on, open, real) ?? null);
+  }
+  entry.hold?.(path, on, open, void 0, req.handle);
+  return done;
+}
+var IDENTITY_OPS = /* @__PURE__ */ new Set([
+  "write",
+  "pwrite",
+  "truncate",
+  "chmod",
+  "utimes",
+  "chown",
+  "lchown"
+]);
 async function dispatchSyncFs(req) {
   const entry = resolveSyncFsToken(req.token);
   if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
+  if (!req.identity || !IDENTITY_OPS.has(req.op)) return dispatchOne(entry, req);
+  const { fs, cwd } = entry;
+  const path = fs.resolvePath(cwd, req.path);
+  const identified = async (held) => {
+    const own = held ? { ...entry, fs: { ...fs, writeFile: held.writeFile } } : entry;
+    const result = await dispatchOne(own, req);
+    if (!result.ok) return result;
+    if (held && !held.direct) return json2(null);
+    const look = req.op === "lchown" ? fs.lstat : fs.stat;
+    const st = await look.call(fs, path).catch(() => void 0);
+    return json2(st ? statJson(st) : null);
+  };
+  try {
+    return await (fs.exclusive ? fs.exclusive(path, identified, req.op !== "lchown") : identified());
+  } catch (err) {
+    return toErrno(err);
+  }
+}
+async function dispatchOne(entry, req) {
   const { fs, cwd } = entry;
   try {
     const path = fs.resolvePath(cwd, req.path);
     if (req.op === "kept") return json2(entry.keptFor?.(req.handle ?? -1) !== void 0);
     if (req.op === "stat" && req.handle !== void 0) return await keptStat(entry, req);
+    if (req.op === "hold") return holdOp(entry, path, req);
+    const refused2 = await guarded(entry, path, req);
+    if (refused2) return refused2;
     if (req.op === "statfs") return json2(await entry.statfs?.(path) ?? await storageUsage());
-    if (req.op === "hold") {
-      const [on, open] = [((req.mode ?? 0) & 1) === 1, ((req.mode ?? 0) & 2) === 2];
-      if (on && open) {
-        const real = await fs.realpath?.(path, true).catch(() => path);
-        return json2(entry.hold?.(path, on, open, real) ?? null);
-      }
-      entry.hold?.(path, on, open, void 0, req.handle);
-      return done;
-    }
     if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
       const serve = async () => run(entry, await keptOr(entry, path, req.handle), req);
@@ -8149,9 +8528,9 @@ function mountTable(mounts = []) {
   for (const m of mounts) {
     const options = Object.entries(m.options).map(([k, v]) => v === "" ? k : `${k}=${v}`);
     if (m.state !== "ok") options.push(m.state);
-    const access = options.includes("ro") ? [] : ["rw"];
+    const access2 = options.includes("ro") ? [] : ["rw"];
     lines2.push(
-      `${field2(m.source)} ${field2(m.target)} ${m.type} ${[...access, ...options].join(",")} 0 0`
+      `${field2(m.source)} ${field2(m.target)} ${m.type} ${[...access2, ...options].join(",")} 0 0`
     );
   }
   return `${lines2.join("\n")}
@@ -8587,8 +8966,8 @@ var ProcTree = class {
   alive(pid) {
     return this.listing().processes.some((p) => p.pid === pid);
   }
-  node(parts) {
-    const [top, leaf, ...rest2] = parts;
+  node(parts2) {
+    const [top, leaf, ...rest2] = parts2;
     if (top === void 0) {
       return {
         kind: "dir",
@@ -8626,9 +9005,9 @@ var ProcTree = class {
     };
   }
   parts(path, follow2) {
-    const parts = path.split("/").filter((p) => p !== "").slice(1);
-    if (parts[0] === "self" && (follow2 || parts.length > 1)) parts[0] = String(this.pid);
-    return parts;
+    const parts2 = path.split("/").filter((p) => p !== "").slice(1);
+    if (parts2[0] === "self" && (follow2 || parts2.length > 1)) parts2[0] = String(this.pid);
+    return parts2;
   }
   find(path, follow2) {
     const node = this.node(this.parts(path, follow2));
@@ -8714,8 +9093,8 @@ function refusalOf(found) {
   return found === false ? { refused: "ENOTDIR" } : found;
 }
 function throughLink(target, done4, todo) {
-  const parts = target.split("/").filter((part) => part !== "");
-  return [target.startsWith("/") ? [] : done4, [...parts, ...todo]];
+  const parts2 = target.split("/").filter((part) => part !== "");
+  return [target.startsWith("/") ? [] : done4, [...parts2, ...todo]];
 }
 async function procAlias(fs, path, follow2) {
   const { readlink, lstat } = fs;
@@ -8725,14 +9104,14 @@ async function procAlias(fs, path, follow2) {
     () => false
   );
   if (!physical) return void 0;
-  const walk = procWalk(path, follow2);
-  let step = walk.next();
+  const walk2 = procWalk(path, follow2);
+  let step = walk2.next();
   while (!step.done) {
     const { at, check } = step.value;
     const link2 = await readlink.call(fs, at).catch(() => void 0);
     const isDir = (st) => st.isDirectory === true;
     const target = link2 ?? (check ? await lstat.call(fs, at).then(isDir, failed) : true);
-    step = walk.next(target);
+    step = walk2.next(target);
   }
   return step.value;
 }
@@ -9966,7 +10345,9 @@ var VfsNode = class {
       this.ranged = new AsyncRangedFile(io, this.path, this.pin.size, this.pin.version);
       return this.ranged;
     }
-    const st = io && !this.orphaned ? await this.fs.stat?.(this.path).catch(() => void 0) : void 0;
+    const at = this.path;
+    const st = io && !this.orphaned ? await this.fs.stat?.(at).catch(() => void 0) : void 0;
+    this.note(at, st);
     if (io && st?.ranged) {
       this.ranged = new AsyncRangedFile(io, this.path, st.size ?? 0, st.version);
       return this.ranged;
@@ -10026,12 +10407,23 @@ var VfsNode = class {
     const stat = this.fs.stat?.bind(this.fs);
     if (!stat || this.orphaned) return Promise.resolve(void 0);
     const parent = this.path.slice(0, this.path.lastIndexOf("/")) || "/";
-    this.cap ??= stat(this.path).catch(() => stat(parent)).then(
+    const at = this.path;
+    this.cap ??= stat(at).then((st) => {
+      this.note(at, st);
+      return st;
+    }).catch(() => stat(parent)).then(
       (st) => st.maxFile,
       () => void 0
     );
     return this.cap;
   }
+  seen;
+  note(path, st) {
+    if (st?.ino !== void 0) this.seen = { path, ino: st.ino };
+  }
+  known() {
+    return this.seen?.path === this.path && !this.orphaned ? this.seen.ino : void 0;
+  }
   async fits(end) {
     const max = await this.limit();
     if (max !== void 0 && end > max) throw new KernelError("EFBIG");
@@ -10079,10 +10471,10 @@ var VfsNode = class {
       this.serial(() => this.flush()).catch(() => void 0);
     }, delay);
   }
-  ensure(need) {
+  ensure(need2) {
     const cur = this.data ?? new Uint8Array(0);
-    if (cur.length >= need) return cur;
-    const grown = new Uint8Array(Math.max(need, cur.length * 2, 256));
+    if (cur.length >= need2) return cur;
+    const grown = new Uint8Array(Math.max(need2, cur.length * 2, 256));
     grown.set(cur.subarray(0, this.length));
     this.data = grown;
     return grown;
@@ -10125,14 +10517,14 @@ var VfsNodes = class {
     return run2;
   }
   async entryKey(path) {
-    const parent = parentOf5(path);
+    const parent = parentOf3(path);
     const dir = await this.real(parent, true, () => realDir(this.fs, parent));
     return joinName(dir, path.slice(path.lastIndexOf("/") + 1));
   }
   targetKey(path) {
     return this.real(path, true, () => realTarget(this.fs, path));
   }
-  async real(path, follow2, walk) {
+  async real(path, follow2, walk2) {
     if (this.fs.realpath) {
       try {
         return await this.fs.realpath(path, follow2);
@@ -10140,13 +10532,13 @@ var VfsNodes = class {
         if (errCode(err) === "ELOOP") throw err;
       }
     }
-    return walk();
+    return walk2();
   }
   createExclusive(path, owner) {
     return this.onEntry(path, async () => {
       const node = this.byPath.get(path);
       const held = node ? await node.serial(async () => node.holds()) : false;
-      if (held || await present(this.fs, path)) throw fsError("EEXIST", path);
+      if (held || await present2(this.fs, path)) throw fsError("EEXIST", path);
       await this.fs.writeFile(path, new Uint8Array(0), owner);
     });
   }
@@ -10206,13 +10598,13 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable = false, id2) {
+  open(path, pin, writable2 = false, id2) {
     const node = this.named(path, id2) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
     node.opens++;
-    if (writable) node.writers++;
+    if (writable2) node.writers++;
     return node;
   }
-  adopt(path, contents2, dirty, writable = false, id2) {
+  adopt(path, contents2, dirty, writable2 = false, id2) {
     let node = this.named(path, id2);
     if (!node) {
       node = this.create(path, id2, new VfsNode(this.fs, path, contents2, false, dirty));
@@ -10220,7 +10612,7 @@ var VfsNodes = class {
       node.replace(contents2);
     }
     node.opens++;
-    if (writable) node.writers++;
+    if (writable2) node.writers++;
     return node;
   }
   holds(prefix) {
@@ -10232,11 +10624,11 @@ var VfsNodes = class {
       if (node.writers > 0 && within5(path, prefix)) return true;
     return false;
   }
-  closed(node, writable = false) {
+  closed(node, writable2 = false) {
     node.opens--;
-    if (writable) node.writers--;
+    if (writable2) node.writers--;
     if (node.opens > 0) {
-      if (writable && node.writers === 0) this.onClosed?.(node.path);
+      if (writable2 && node.writers === 0) this.onClosed?.(node.path);
       return;
     }
     this.forget(node);
@@ -10313,7 +10705,7 @@ var VfsNodes = class {
     }
   }
 };
-async function present(fs, path, follow2 = false) {
+async function present2(fs, path, follow2 = false) {
   const look = (follow2 ? void 0 : fs.lstat) ?? fs.stat;
   try {
     await (look ? look.call(fs, path) : fs.readFileBuffer(path));
@@ -10327,7 +10719,7 @@ function errCode(err) {
   return err?.code;
 }
 async function targetDir(fs, path) {
-  return parentOf5(await realTarget(fs, path).catch(() => path));
+  return parentOf3(await realTarget(fs, path).catch(() => path));
 }
 async function refuseReadonly(fs, path, flags, opts = {}) {
   const writes = (flags & O_ACCMODE) !== 0 || opts.truncate === true;
@@ -10345,6 +10737,18 @@ async function refuseReadonly(fs, path, flags, opts = {}) {
 function keepingOpen(fs, nodes) {
   return {
     ...fs,
+    async exclusive(path, run2, follow2 = true) {
+      const at = fs.resolvePath("/", path);
+      const key = follow2 ? nodes.targetKey(at) : nodes.entryKey(at);
+      const locked = await key.catch(() => at);
+      return nodes.onEntry(
+        locked,
+        () => run2({
+          writeFile: (p, content, owner) => fs.writeFile(p, content, owner),
+          direct: locked === at
+        })
+      );
+    },
     async rm(path, options) {
       const at = await nodes.entryKey(fs.resolvePath("/", path));
       await nodes.unlinking(at);
@@ -10377,10 +10781,10 @@ function keepingOpen(fs, nodes) {
   };
 }
 function vfsFile(fs, opts, nodes) {
-  const access = opts.flags & O_ACCMODE;
-  const readable = access !== O_WRONLY;
-  const writable = access === O_WRONLY || access === O_RDWR;
-  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable, opts.id) : nodes.open(opts.path, opts.pin, writable, opts.id);
+  const access2 = opts.flags & O_ACCMODE;
+  const readable2 = access2 !== O_WRONLY;
+  const writable2 = access2 === O_WRONLY || access2 === O_RDWR;
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true, writable2, opts.id) : nodes.open(opts.path, opts.pin, writable2, opts.id);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -10401,12 +10805,12 @@ function vfsFile(fs, opts, nodes) {
     return op();
   });
   return new OpenFile({
-    read: readable ? (max) => serial(async () => {
+    read: readable2 ? (max) => serial(async () => {
       const out = await node.pread(max, offset);
       offset += out.length;
       return out;
     }) : void 0,
-    write: writable ? (bytes) => serial(async () => {
+    write: writable2 ? (bytes) => serial(async () => {
       if (opts.flags & O_APPEND) offset = await node.size();
       offset += await node.pwrite(bytes, offset);
       return bytes.length;
@@ -10421,15 +10825,15 @@ function vfsFile(fs, opts, nodes) {
       return offset;
     }),
     pread: (max, at) => serial(() => {
-      if (!readable) throw new KernelError("EBADF");
+      if (!readable2) throw new KernelError("EBADF");
       return node.pread(max, at);
     }),
     pwrite: (bytes, at) => serial(() => {
-      if (!writable) throw new KernelError("EBADF");
+      if (!writable2) throw new KernelError("EBADF");
       return node.pwrite(bytes, at);
     }),
     resize: (size) => serial(() => {
-      if (!writable) throw new KernelError("EBADF");
+      if (!writable2) throw new KernelError("EBADF");
       return node.truncate(size);
     }),
     stat: () => serial(async () => ({
@@ -10437,13 +10841,14 @@ function vfsFile(fs, opts, nodes) {
       size: await node.size(),
       ...node.orphaned ? { orphan: true } : {}
     })),
+    known: () => node.known(),
     flush: () => serial(() => node.flush()),
     close: () => node.serial(async () => {
       try {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node, writable);
+        nodes?.closed(node, writable2);
       }
     })
   });
@@ -10814,7 +11219,7 @@ var WasmProcess = class {
         this.fds.installAt(fd, this.openVfsFile(open));
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
-          const fresh = this.options.owners && !await present(this.options.fs, path, true);
+          const fresh = this.options.owners && !await present2(this.options.fs, path, true);
           this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
           await this.fds.get(fd).file.stat?.();
           if (fresh) await this.options.fs.chown?.(path, { ...this.newOwner(), kind: "new" });
@@ -10822,7 +11227,7 @@ var WasmProcess = class {
       } else {
         this.fds.installAt(fd, this.openVfsFile(open, await nodes.identify(path)));
       }
-      if (req.existing && !await present(this.options.fs, path, true)) {
+      if (req.existing && !await present2(this.options.fs, path, true)) {
         throw new KernelError("ENOENT");
       }
     } catch (err) {
@@ -10831,6 +11236,20 @@ var WasmProcess = class {
     }
     return fd;
   }
+  async identified(stat, known) {
+    const first = await stat();
+    if (first.orphan) return first;
+    const ino = known?.();
+    if (ino !== void 0) return { ...first, ino };
+    const { fs } = this.options;
+    const look = async () => {
+      const now = await stat();
+      if (now.path !== first.path || now.orphan) return now;
+      const st = await fs.stat?.(now.path).catch(() => void 0);
+      return st?.ino === void 0 ? now : { ...now, ino: st.ino };
+    };
+    return fs.exclusive ? fs.exclusive(first.path, look) : look();
+  }
   newOwner() {
     if (!this.options.owners) return void 0;
     return { uid: this.cred.euid, gid: this.cred.egid, mode: 438 & ~this.umask };
@@ -10842,14 +11261,14 @@ var WasmProcess = class {
     if (req.flags & WRITE_ACCESS || req.create || req.truncate || req.exclusive) {
       throw new KernelError("EROFS");
     }
-    const tree = new ProcTree(
+    const tree2 = new ProcTree(
       {
         procList: () => this.options.processes?.() ?? { boot: 0, processes: [] },
         mountList: () => this.options.mounts?.() ?? []
       },
       (await this.options.identity?.())?.pid ?? this.pid
     );
-    return memoryFile(tree.read(path), path, req.position);
+    return memoryFile(tree2.read(path), path, req.position);
   }
   openVfsFile(req, id2) {
     return vfsFile(
@@ -10992,7 +11411,11 @@ var WasmProcess = class {
         await file.resize(req.size);
         return { ok: true, kind: "void" };
       case "fd-vfs-stat":
-        return { ok: true, kind: "json", json: await file.stat() };
+        return {
+          ok: true,
+          kind: "json",
+          json: req.identity ? await this.identified(file.stat.bind(file), file.known?.bind(file)) : await file.stat()
+        };
     }
   }
   keptPath;
@@ -11001,7 +11424,7 @@ var WasmProcess = class {
     const held = handle === void 0 ? void 0 : this.keptHandle?.(handle);
     if (held !== void 0) return held;
     const kept = this.keptPath?.(path);
-    return kept !== void 0 && !await present(this.options.fs, path, true) ? kept : path;
+    return kept !== void 0 && !await present2(this.options.fs, path, true) ? kept : path;
   }
   async promote(req) {
     if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
@@ -11511,6 +11934,7 @@ function inherited(opts) {
 function holdingToken(opts, holds, caller) {
   return mintSyncFsToken({
     ...opts.owners ? caller : {},
+    ...opts.dac ? { dac: opts.dac, pid: opts.pid } : {},
     fs: opts.fs,
     cwd: opts.cwd,
     ...opts.statfs ? { statfs: opts.statfs } : {},
@@ -12140,9 +12564,9 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open = false;
   const reply = (message3, transfer = []) => port.postMessage(message3, transfer);
   async function hello(message3) {
-    const refused = driverVersionError(message3.protocol);
-    if (refused) {
-      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused, errno: "EPROTO" } });
+    const refused2 = driverVersionError(message3.protocol);
+    if (refused2) {
+      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused2, errno: "EPROTO" } });
       return;
     }
     try {
@@ -12684,7 +13108,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     }, againMs);
     timer.unref?.();
   });
-  async function writable(client, path, flags) {
+  async function writable2(client, path, flags) {
     const { ifMatch: _, ...asked } = flags;
     const opening = () => client.call("open", { path: rel(path), ...asked });
     try {
@@ -12715,7 +13139,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     async open(path, flags) {
       const client = current();
       const token = client.token;
-      const { opened: opened2, restore } = await writable(client, path, flags);
+      const { opened: opened2, restore } = await writable2(client, path, flags);
       if (flags.ifMatch !== void 0 && opened2.attr?.etag !== flags.ifMatch) {
         await client.call("release", { fh: opened2.fh }, true);
         throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
@@ -12888,7 +13312,7 @@ var PORT_DEAD_MS = 1e4;
 var PORT_LINGER_MS = 1e3;
 function timed(transport, ms) {
   const inflight = /* @__PURE__ */ new Set();
-  const guard = (name2, run2, late, expire) => new Promise((resolve, reject) => {
+  const guard2 = (name2, run2, late, expire) => new Promise((resolve, reject) => {
     let expired = false;
     const running = run2();
     inflight.add(running);
@@ -12937,15 +13361,15 @@ function timed(transport, ms) {
     },
     retire: (why) => transport.retire?.(why),
     ...transport.cleanup ? { cleanup } : {},
-    call: (op, body, handle) => guard(
+    call: (op, body, handle) => guard2(
       op,
       () => transport.call(op, body, handle),
       op === "open" ? release : void 0,
       op === "release" ? (running) => void cleanup("release", body ?? {}, running).catch(() => {
       }) : void 0
     ),
-    read: (fh, offset, size, ifMatch) => guard("read", () => transport.read(fh, offset, size, ifMatch)),
-    write: (fh, offset, bytes) => guard("write", () => transport.write(fh, offset, bytes)),
+    read: (fh, offset, size, ifMatch) => guard2("read", () => transport.read(fh, offset, size, ifMatch)),
+    write: (fh, offset, bytes) => guard2("write", () => transport.write(fh, offset, bytes)),
     watch: (signal, onEvent, onOpen) => transport.watch(signal, onEvent, onOpen)
   };
 }
@@ -13223,10 +13647,10 @@ var ChunkedBytes = class {
     }
     this.size = size;
   }
-  room(index, need) {
+  room(index, need2) {
     const chunk2 = this.chunks[index];
-    if (chunk2 && chunk2.length >= need) return chunk2;
-    const grown = new Uint8Array(Math.min(CHUNK3, Math.max(need, (chunk2?.length ?? 0) * 2)));
+    if (chunk2 && chunk2.length >= need2) return chunk2;
+    const grown = new Uint8Array(Math.min(CHUNK3, Math.max(need2, (chunk2?.length ?? 0) * 2)));
     if (chunk2) grown.set(chunk2);
     this.chunks[index] = grown;
     return grown;
@@ -13273,14 +13697,14 @@ function tmpfs() {
   const root = make("directory", 16877);
   const handles = /* @__PURE__ */ new Map();
   let nextFh = 0;
-  const parts = (path) => path.split("/").filter(Boolean);
+  const parts2 = (path) => path.split("/").filter(Boolean);
   const place = (dir, name2, node) => {
     dir.children.set(name2, node);
     dir.mtime = Date.now();
   };
   function find(path) {
     let node = root;
-    for (const name2 of parts(path)) {
+    for (const name2 of parts2(path)) {
       if (node.kind !== "directory") throw fsError2("ENOTDIR", path);
       const next2 = node.children.get(name2);
       if (!next2) throw fsError2("ENOENT", path);
@@ -13289,7 +13713,7 @@ function tmpfs() {
     return node;
   }
   function parent(path) {
-    const names = parts(path);
+    const names = parts2(path);
     const name2 = names.pop();
     if (name2 === void 0) throw fsError2("EBUSY", "the root of a mount");
     const dir = find(`/${names.join("/")}`);
@@ -13374,8 +13798,8 @@ function tmpfs() {
       dir.mtime = Date.now();
     },
     async rename(from, to) {
-      const a = `/${parts(from).join("/")}`;
-      const b = `/${parts(to).join("/")}`;
+      const a = `/${parts2(from).join("/")}`;
+      const b = `/${parts2(to).join("/")}`;
       if (b !== a && b.startsWith(`${a}/`)) throw fsError2("EINVAL", `${to} is inside ${from}`);
       const source = parent(from);
       const node = source.dir.children.get(source.name);
@@ -13734,11 +14158,13 @@ var Launcher = class {
   booting = new AbortController();
   fstab = Promise.resolve([]);
   usersMode;
+  dac;
   nextPid = 1e3;
   boot = Date.now();
   terminals = 0;
   constructor(options) {
     this.usersMode = usersMode(options.users);
+    this.dac = this.usersMode === "off" ? void 0 : new Dac(this.usersMode, options.onDenial);
     if (this.owners) options.fs.trackOwners?.();
     this.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
@@ -14069,6 +14495,7 @@ var Launcher = class {
       ...req.umask !== void 0 ? { umask: req.umask } : {},
       cred: req.cred,
       ...this.owners ? { owners: true } : {},
+      ...this.dac ? { dac: this.dac } : {},
       program: req.program,
       argv0: req.argv0,
       args: req.args,
@@ -14670,10 +15097,11 @@ function usersOp(l, req) {
   if (req.op === "groups-remove-member") return l.users.removeMember(req.group, req.user);
   return l.users.list();
 }
-function hostOptions(req) {
+function hostOptions(req, port) {
   return {
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
-    ...req.users !== void 0 ? { users: req.users } : {}
+    ...req.users !== void 0 ? { users: req.users } : {},
+    ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {}
   };
 }
 function serveKernel(port, deps) {
@@ -14750,7 +15178,7 @@ function serveKernel(port, deps) {
         ...deps.createDriverWorker ? { createDriverWorker: deps.createDriverWorker } : {},
         ...req.modules ? { modules: req.modules } : {},
         ...req.env ? { env: req.env } : {},
-        ...hostOptions(req),
+        ...hostOptions(req, port),
         ...net,
         ...media ? { media } : {},
         onMountPending: (medium) => port.postMessage({ medium }),