@ai-ecoverse/slicc-kernel 1.178.1 → 1.178.3

package/dist/kernel-worker.js

@@ -1339,8 +1339,8 @@ var RemoteWatch = class {
     const { held = [], pending = [] } = await this.locks.query();
     if (![...held, ...pending].some((lock) => lock.name === name2)) {
       this.mourned.delete(peer);
-      const live = this.peers.has(peer) || this.flushes.has(peer);
-      if (tries > 1 && live) {
+      const live2 = this.peers.has(peer) || this.flushes.has(peer);
+      if (tries > 1 && live2) {
         setTimeout(() => void this.mourn(peer, tries - 1), MOURN_RETRY_MS);
       } else this.flushedAt(peer);
       return;
@@ -1830,11 +1830,11 @@ async function positioned(handle, op) {
     }
     return;
   }
-  const writable2 = await handle.createWritable({ keepExistingData: true });
+  const writable3 = await handle.createWritable({ keepExistingData: true });
   try {
     await op({
       write: async (at, bytes) => {
-        await writable2.write({
+        await writable3.write({
           type: "write",
           position: at,
           data: bytes
@@ -1842,15 +1842,15 @@ async function positioned(handle, op) {
         extent.wrote(at + bytes.length);
       },
       truncate: async (n) => {
-        await writable2.truncate(n);
+        await writable3.truncate(n);
         extent.cut(n);
       }
     });
   } catch (err) {
-    await writable2.abort();
+    await writable3.abort();
     throw err;
   }
-  await writable2.close();
+  await writable3.close();
   if (extent.big()) extent.check((await handle.getFile()).size);
 }
 function syncAccessHandles(scope = globalThis) {
@@ -2936,21 +2936,21 @@ var OpfsFs = class {
   }
   async writeSession(path, truncate) {
     const [handle, , target] = await this.fileFor(path);
-    const writable2 = await this.retrying(
+    const writable3 = await this.retrying(
       path,
       () => this.io(handle.createWritable({ keepExistingData: !truncate })),
       true
     );
     return {
-      write: (at, bytes) => writable2.write({ type: "write", position: at, data: bytes }).catch((err) => {
+      write: (at, bytes) => writable3.write({ type: "write", position: at, data: bytes }).catch((err) => {
         throw translate(err, path, "write", false);
       }),
-      truncate: (size) => writable2.truncate(size).catch((err) => {
+      truncate: (size) => writable3.truncate(size).catch((err) => {
         throw translate(err, path, "write", false);
       }),
       close: async () => {
         this.wrote(handle);
-        await writable2.close().catch((err) => {
+        await writable3.close().catch((err) => {
           this.wrote(handle);
           throw translate(err, path, "commit", false);
         });
@@ -3002,19 +3002,19 @@ var OpfsFs = class {
     const [file, existed, target] = await this.fileFor(path, owner?.existing !== true);
     if (!existed) await this.stampNew(target, owner, false);
     if (!existed && content.length === 0) return;
-    let writable2;
+    let writable3;
     this.wrote(file);
     try {
-      writable2 = await this.io(file.createWritable());
-      await writable2.write(content);
-      await writable2.close();
+      writable3 = await this.io(file.createWritable());
+      await writable3.write(content);
+      await writable3.close();
       if (typeof content !== "string" && content.length >= CHECKED_BYTES) {
         const extent = new Extent();
         extent.cut(content.length);
         extent.check((await file.getFile()).size);
       }
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       throw translate(err, path, "commit", false);
     } finally {
       this.wrote(file);
@@ -3739,7 +3739,7 @@ var OpfsFs = class {
       created4 = true;
     }
     let target = destination;
-    let writable2;
+    let writable3;
     let handle;
     try {
       const kept = created4 ? this.files.get(destination) : void 0;
@@ -3758,11 +3758,11 @@ var OpfsFs = class {
         if (entry?.fifo || entry?.socket) throw fsError("ENXIO", to);
       }
       this.wrote(handle);
-      writable2 = await handle.createWritable();
-      await writable2.write(file);
-      await writable2.close();
+      writable3 = await handle.createWritable();
+      await writable3.write(file);
+      await writable3.close();
     } catch (err) {
-      await writable2?.abort().catch(() => void 0);
+      await writable3?.abort().catch(() => void 0);
       if (created4) await this.rm(target, { file: true }).catch(() => void 0);
       throw translate(err, to, "commit", false);
     } finally {
@@ -3851,10 +3851,10 @@ var OpfsFs = class {
     }
     if (handle.kind === "file") {
       const made2 = await this.io(dir.getFileHandle(name2, { create: true }));
-      const writable2 = await this.io(made2.createWritable());
+      const writable3 = await this.io(made2.createWritable());
       const file = await this.io(handle.getFile());
-      await writable2.write(file);
-      await writable2.close();
+      await writable3.write(file);
+      await writable3.close();
       copies?.set(rest2, { before: copies.get(rest2)?.before ?? file.lastModified, made: made2 });
       return;
     }
@@ -8777,7 +8777,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.178.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.178.3" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -10059,9 +10059,9 @@ var UnlinkedKeeper = class {
         if (kept.whole) return kept.undoing(async () => void 0);
         await kept.undoing(
           () => replace(target, async (gated, sealed) => {
-            const pinned = await keeper.pin(target, gated, sealed);
-            if (pinned.moved.has(target)) pinned.commit();
-            else await keeper.settle(pinned, () => fs.rm(path, options));
+            const pinned2 = await keeper.pin(target, gated, sealed);
+            if (pinned2.moved.has(target)) pinned2.commit();
+            else await keeper.settle(pinned2, () => fs.rm(path, options));
           })
         );
       },
@@ -10074,8 +10074,8 @@ var UnlinkedKeeper = class {
           () => keeper.marks.around(
             [source],
             () => replace(target, async (gated, sealed) => {
-              const pinned = await keeper.pin(target, gated, sealed);
-              await keeper.settle(pinned, () => fs.rename(from, to));
+              const pinned2 = await keeper.pin(target, gated, sealed);
+              await keeper.settle(pinned2, () => fs.rename(from, to));
             })
           )
         );
@@ -10110,14 +10110,14 @@ var UnlinkedKeeper = class {
     }
     return false;
   }
-  async settle(pinned, op) {
+  async settle(pinned2, op) {
     try {
       await op();
     } catch (err) {
-      await pinned.rollback();
+      await pinned2.rollback();
       throw err;
     }
-    pinned.commit();
+    pinned2.commit();
   }
   heldWithin(target) {
     const held = /* @__PURE__ */ new Map();
@@ -12641,6 +12641,13 @@ var SpawnError = class extends Error {
     this.code = code;
   }
 };
+var ChangedError = class extends SpawnError {
+  notice;
+  constructor(notice) {
+    super("EPERM");
+    this.notice = notice;
+  }
+};
 function interrupted(signal) {
   const { promise, reject } = Promise.withResolvers();
   const fail2 = () => reject(new KernelError("EINTR"));
@@ -17082,11 +17089,11 @@ function systemFile(name2, listing, now, memory) {
       listing.processes.reduce((sum2, p) => sum2 + p.memory, 0)
     );
   }
-  const live = listing.processes.filter((p) => p.state !== "Z");
+  const live2 = listing.processes.filter((p) => p.state !== "Z");
   if (name2 === "loadavg") {
     const last = Math.max(0, ...listing.processes.map((p) => p.pid));
     const [one, five, fifteen] = (listing.load ?? [0, 0, 0]).map((n) => n.toFixed(2));
-    return `${one} ${five} ${fifteen} 1/${live.length} ${last}
+    return `${one} ${five} ${fifteen} 1/${live2.length} ${last}
 `;
   }
   const sum = (key) => listing.cpu?.[key] ?? listing.processes.reduce((n, p) => n + (p[key] ?? 0), 0);
@@ -19575,30 +19582,49 @@ function timestampKey(owner, type) {
   }
   return parent ? JSON.stringify(["ppid", parent.pid, parent.started]) : void 0;
 }
+function boundKey(bound3) {
+  return JSON.stringify(
+    Object.keys(bound3).sort().map((path) => [path, bound3[path]])
+  );
+}
+function writable2(bound3) {
+  return bound3 !== void 0 && Object.keys(bound3).length > 0;
+}
+function live(stamp, policy, now) {
+  return stamp.at <= now && (policy.minutes < 0 || now - stamp.at < policy.minutes * MINUTE_MS2);
+}
 var Timestamps = class {
   users = /* @__PURE__ */ new Map();
   now;
   constructor(now) {
     this.now = now;
   }
-  current(owner, policy) {
+  current(owner, policy, bound3) {
     if (policy.minutes === 0) return false;
     const key = timestampKey(owner, policy.type);
-    const at = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
-    if (at === void 0) return false;
+    const stamp = key === void 0 ? void 0 : this.users.get(owner.uid)?.get(key);
+    if (stamp === void 0) return false;
     const now = this.now();
-    return at <= now && (policy.minutes < 0 || now - at < policy.minutes * MINUTE_MS2);
+    if (!live(stamp, policy, now)) {
+      this.drop(owner.uid, key);
+      return false;
+    }
+    if (!writable2(bound3)) return true;
+    return stamp.covered.has(boundKey(bound3));
   }
-  stamp(owner, policy) {
+  stamp(owner, policy, bound3) {
     const key = policy.minutes === 0 ? void 0 : timestampKey(owner, policy.type);
     if (key === void 0) return false;
     const now = this.now();
     const records = this.users.get(owner.uid) ?? /* @__PURE__ */ new Map();
     this.users.set(owner.uid, records);
+    const prior = records.get(key);
+    const covered = prior !== void 0 && live(prior, policy, now) ? prior.covered : /* @__PURE__ */ new Set();
+    if (writable2(bound3)) covered.add(boundKey(bound3));
     records.delete(key);
-    records.set(key, now);
-    for (const [old, at] of records) {
-      const stale = policy.minutes > 0 && (at > now || now - at >= policy.minutes * MINUTE_MS2);
+    records.set(key, { at: now, covered });
+    for (const [old, stamp] of records) {
+      const stale = policy.minutes > 0 && !live(stamp, policy, now);
       if (stale || records.size > TIMESTAMPS_MAX) records.delete(old);
     }
     return true;
@@ -19612,6 +19638,11 @@ var Timestamps = class {
   remove(uid) {
     this.users.delete(uid);
   }
+  drop(uid, key) {
+    const records = this.users.get(uid);
+    records?.delete(key);
+    if (records?.size === 0) this.users.delete(uid);
+  }
 };
 
 // src/sudoers.ts
@@ -19620,8 +19651,10 @@ var SUDOERS_D = "/etc/sudoers.d";
 var NAME4 = /^[a-z_][a-z0-9_.-]*$/;
 var WORD = String.raw`(?:'[^']*'|"(?:[^"\\]|\\[\s\S])*"|\\[\s\S]|[^\s'"\\])+`;
 var KERNEL_FORM = new RegExp(
-  String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()]*)\)\s+)?(?:Cwd\s+(${WORD})\s+)?(?:Stdin\s+(\S+)\s+)?Cmnd(?:\s+(.*))?$`
+  String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()]*)\)\s+)?(?:Cwd\s+(${WORD})\s+)?(?:Stdin\s+(\S+)\s+)?((?:Sha256\s+${WORD}\s+)*)Cmnd(?:\s+(.*))?$`
 );
+var SHA256_CLAUSE = new RegExp(String.raw`Sha256\s+(${WORD})`, "g");
+var HEX = /^[0-9a-f]{64}$/;
 var SUDOERS_FORM = /^(\S+)\s+([^\s=]+)\s*=\s*(.*)$/;
 var RUNAS = /^\(([^()]*)\)\s*/;
 var TAG = /^([A-Z_]+)\s*:\s*/;
@@ -19630,7 +19663,7 @@ var PLAIN2 = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var CONTROL2 = /[\p{Cc}\u2028\u2029]/u;
 var CONTROLS = /[\p{Cc}\u2028\u2029]/gu;
 var SHOWN_MAX = 60;
-var KERNEL_SYNTAX = "[NOPASSWD] <user|%group|ALL> [(<target>)] [Cwd <dir>] [Stdin none] Cmnd <command\u2026|*>";
+var KERNEL_SYNTAX = "[NOPASSWD] <user|%group|ALL> [(<target>)] [Cwd <dir>] [Stdin none] [Sha256 <file>=<sha256>\u2026] Cmnd <command\u2026|*>";
 var SUDOERS_SYNTAX = "<user|%group|ALL> ALL=[(<target>[,<target>\u2026])] [NOPASSWD:] <command\u2026|ALL>";
 var EXPECTED = `expected '${KERNEL_SYNTAX}' or '${SUDOERS_SYNTAX}'`;
 var TIMESTAMP_TIMEOUT = 5;
@@ -19797,6 +19830,23 @@ function commandOf2(text, after) {
   if (only && /\s""$/.test(text)) return { path, args: [] };
   return args.length === 0 ? { path } : { path, args };
 }
+function sha256Of(clauses) {
+  const files = {};
+  for (const [, word = ""] of clauses.matchAll(SHA256_CLAUSE)) {
+    const [text = ""] = splitWords(word) ?? [];
+    const at = text.lastIndexOf("=");
+    const path = text.slice(0, at);
+    const hex4 = text.slice(at + 1).toLowerCase();
+    if (!path.startsWith("/") || !HEX.test(hex4)) {
+      return `Sha256 expects <absolute file>=<sha256 in hex>, not ${shown(word)}`;
+    }
+    files[normalizePath(path)] = hex4;
+  }
+  return files;
+}
+function sha256Text(files) {
+  return Object.entries(files).map(([path, hex4]) => `Sha256 ${quoteWord(`${path}=${hex4}`)} `).join("");
+}
 function targetError(list) {
   if (list.includes(",")) {
     return `(${list}) names one user in this form: write one line per user, or use '${SUDOERS_SYNTAX}'`;
@@ -19804,19 +19854,22 @@ function targetError(list) {
   return `expected one user name or ALL in (\u2026), not ${shown(`(${list})`)}`;
 }
 function kernelRules(m) {
-  const [, nopasswd, who = "", target = "root", dir, stdin, rest2 = ""] = m;
+  const [, nopasswd, who = "", target = "root", dir, stdin, sums = "", rest2 = ""] = m;
   const bad = whoError(who);
   if (bad !== void 0) return bad;
   if (target !== "ALL" && !NAME4.test(target)) return targetError(target);
   const cwd = dir === void 0 ? void 0 : cwdOf(dir);
   if (cwd === "") return `Cwd expects one absolute directory, not ${shown(dir)}`;
   if (stdin !== void 0 && stdin !== "none") return `Stdin takes none, not ${shown(stdin)}`;
+  const sha2564 = sha256Of(sums);
+  if (typeof sha2564 === "string") return sha2564;
   const rule = {
     nopasswd: !!nopasswd,
     who,
     target,
     ...cwd !== void 0 ? { cwd } : {},
-    ...stdin === "none" ? { stdin: "none" } : {}
+    ...stdin === "none" ? { stdin: "none" } : {},
+    ...sums === "" ? {} : { sha256: sha2564 }
   };
   const text = rest2.trim();
   if (text === "*") return [{ ...rule, cmnd: "*" }];
@@ -20069,12 +20122,26 @@ var RAN_ONCE = "sudo: ran once; this command line can't be recorded as always";
 var ROOT_ONLY_MAX = 64;
 var OPERANDS_MAX = 256;
 var PATH_MAX = 4096;
+function userWritable(bound3) {
+  const files = Object.entries(bound3).map(([path, hex4]) => ({ path, sha256: hex4 }));
+  return files.length > 0 ? { userWritable: files } : {};
+}
 function stdinMatches(rule, stdin) {
   return rule.stdin === void 0 || stdin === "tty" || stdin === "none";
 }
 function recordable(cwd, argv) {
   return !hasControl(cwd) && !argv.some(hasControl);
 }
+function changedText(file) {
+  return `sudo: ${file} changed since it was approved`;
+}
+function changedFile(approved, now) {
+  const files = /* @__PURE__ */ new Set([...Object.keys(approved), ...Object.keys(now)]);
+  return [...files].find((file) => approved[file] !== now[file]);
+}
+function pinned(rule, bound3) {
+  return rule.sha256 === void 0 || changedFile(rule.sha256, bound3) === void 0;
+}
 var VISUDO_FILES_MAX = 64;
 var VISUDO_TEXT_MAX = 1024 * 1024;
 function visudoCall(req) {
@@ -20205,11 +20272,13 @@ function usable(parsed2) {
 function policyOf(settings) {
   return { type: settings.timestampType, minutes: settings.timestampTimeout };
 }
-function described(rule) {
+function described(rule, writable3) {
   const cmnd = rule.cmnd === "*" ? "ALL" : commandText(rule.cmnd);
   const cwd = rule.cwd === void 0 ? "" : `CWD=${quoteWord(rule.cwd)} `;
   const stdin = rule.stdin === void 0 ? "" : "STDIN=none ";
-  return `    (${rule.target}) ${cwd}${stdin}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}`;
+  const sums = Object.entries(rule.sha256 ?? {}).map(([path, hex4]) => `SHA256=${quoteWord(path)}:${hex4} `).join("");
+  const flag = writable3 ? "  # user-writable command" : "";
+  return `    (${rule.target}) ${cwd}${stdin}${sums}${rule.nopasswd ? "NOPASSWD: " : ""}${cmnd}${flag}`;
 }
 var Sudo = class {
   o;
@@ -20400,15 +20469,31 @@ var Sudo = class {
     if (walked.denied !== void 0 || walked.missing) return false;
     return (await this.o.fs.stat(cwd).catch(() => void 0))?.isDirectory === true;
   }
-  async untrusted(path, cwd, word) {
-    const files = this.o.backing ? await this.o.backing(path, cwd) : [];
-    if (!files) return failed2("ENOENT", `sudo: ${word}: command not found`);
-    for (const file of [path, ...files]) {
-      if (!await this.trusted(file)) {
-        return failed2("EPERM", `sudo: ${file} must be root's, and writable by root only`);
-      }
+  async real(file) {
+    const { fs } = this.o;
+    return await fs.realpath?.(file, true).catch(() => file) ?? file;
+  }
+  async digests(files) {
+    const { fs } = this.o;
+    const found = {};
+    for (const file of new Set(files)) {
+      if (await this.trusted(file)) continue;
+      const real = await this.real(file);
+      found[real] = await fs.readFileBuffer(real).then(sha256, () => "");
     }
-    return void 0;
+    return found;
+  }
+  async bound(path, cwd) {
+    const files = this.o.backing ? await this.o.backing(path, cwd) : [];
+    const bound3 = files && await this.digests([path, ...files]);
+    return bound3 && !Object.values(bound3).includes("") ? bound3 : void 0;
+  }
+  async writable(rule) {
+    if (rule.cmnd === "*") return false;
+    const { path } = rule.cmnd;
+    const bound3 = await this.bound(path, "/");
+    if (bound3) return Object.keys(bound3).length > 0;
+    return !await this.trusted(await this.existing(path));
   }
   async locate(word, cwd) {
     const { fs } = this.o;
@@ -20453,7 +20538,7 @@ var Sudo = class {
     const root = cred.euid === 0;
     const rules = root ? [] : policy.rules;
     const mine = rules.filter((rule) => applies(rule.who));
-    if (parsed2.list) return this.listed(self, root, mine, settings.matching);
+    if (parsed2.list) return await this.listed(self, root, mine, settings.matching);
     const session = { caller, self, target, owner, policy: policyOf(settings), parsed: parsed2, signal };
     if (parsed2.validate) return this.validate(session, root, mine, call.cwd);
     return this.command(session, root, mine, call);
@@ -20470,14 +20555,13 @@ var Sudo = class {
       );
     }
     const path = await this.locate(word, cwd);
-    if (!path) return failed2("ENOENT", `sudo: ${word}: command not found`);
-    const untrusted2 = await this.untrusted(path, cwd, word);
-    if (untrusted2) return untrusted2;
+    const bound3 = path && await this.bound(path, cwd);
+    if (!path || !bound3) return failed2("ENOENT", `sudo: ${word}: command not found`);
     const argv = [path, ...args];
     const matching = mine.filter(
-      (rule) => (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === cwd) && stdinMatches(rule, caller.stdin) && commandMatches(rule.cmnd, argv)
+      (rule) => (rule.target === "ALL" || rule.target === target.name) && (rule.cwd === void 0 || rule.cwd === cwd) && stdinMatches(rule, caller.stdin) && commandMatches(rule.cmnd, argv) && pinned(rule, bound3)
     );
-    const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term);
+    const grant = () => this.grant(self, target, cred, parsed2.command, path, cwd, call.term, bound3);
     if (root || matching.some((rule) => rule.nopasswd)) return grant();
     const quoted = argv.map(quoteWord).join(" ");
     if (matching.length === 0) {
@@ -20486,22 +20570,23 @@ var Sudo = class {
         `sudo: ${self.name} is not allowed to run ${quoted} as ${target.name}`
       );
     }
-    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy)) {
-      this.timestamps.stamp(s.owner, s.policy);
+    if (!parsed2.reset && this.timestamps.current(s.owner, s.policy, bound3)) {
+      this.timestamps.stamp(s.owner, s.policy, bound3);
       this.logged(s, cwd, argv);
       return grant();
     }
     if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
     return this.pendingFor(cred.ruid, async () => {
-      const answer2 = await this.ask(s, { argv: parsed2.command, path, cwd });
+      const answer2 = await this.ask(s, { argv: parsed2.command, path, cwd, bound: bound3 });
       if ("error" in answer2) return answer2;
       if (await this.canonical(call.cwd) !== cwd || !await this.reachable(cred, cwd)) {
         return failed2("EACCES", `sudo: ${call.cwd} changed while the request waited`);
       }
-      const changed = await this.untrusted(path, cwd, word);
-      if (changed) return changed;
-      const result = answer2.answer === "once" ? grant() : await this.always(self, target, cwd, argv, recordable(cwd, parsed2.command), grant);
-      if (!("error" in result)) this.stamped(s, answer2);
+      const now = await this.bound(path, cwd);
+      if (!now) return failed2("ENOENT", `sudo: ${word}: command not found`);
+      const shown2 = recordable(cwd, [...parsed2.command, ...Object.keys(bound3)]);
+      const result = answer2.answer === "once" ? grant() : await this.always(self, target, { cwd, argv, bound: bound3 }, now, shown2, grant);
+      if (!("error" in result)) this.stamped(s, answer2, bound3);
       return result;
     });
   }
@@ -20519,7 +20604,7 @@ var Sudo = class {
     if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
     const cwd = await this.canonical(dir) ?? normalizePath(dir);
     return this.pendingFor(s.caller.cred.ruid, async () => {
-      const answer2 = await this.ask(s, { argv: [], path: "", cwd, validate: true });
+      const answer2 = await this.ask(s, { argv: [], path: "", cwd, bound: {}, validate: true });
       if ("error" in answer2) return answer2;
       if (!answer2.person) await s.caller.report?.(NOT_STAMPED);
       this.stamped(s, answer2);
@@ -20535,8 +20620,8 @@ var Sudo = class {
       this.pending.delete(uid);
     }
   }
-  stamped(s, answer2) {
-    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy);
+  stamped(s, answer2, bound3 = {}) {
+    if (answer2.person && !s.parsed.reset) this.timestamps.stamp(s.owner, s.policy, bound3);
   }
   logged(s, cwd, argv) {
     const { caller, self, target, owner, policy } = s;
@@ -20547,14 +20632,17 @@ var Sudo = class {
       `sudo: ${self.name} : TTY=${tty} ; PWD=${quoteWord(cwd)} ; USER=${target.name} ; TIMESTAMP=${type} ; COMMAND=${command}`
     );
   }
-  async always(self, target, cwd, argv, shown2, grant) {
+  async always(self, target, line, now, shown2, grant) {
+    const { cwd, argv, bound: bound3 } = line;
     if (!shown2 || !recordable(cwd, argv)) return { ...grant(), notice: RAN_ONCE };
-    if (!await this.remember(self, target, cwd, argv)) {
+    const changed = changedFile(bound3, now);
+    if (changed !== void 0) return failed2("EPERM", changedText(changed));
+    if (!await this.remember(self, target, line)) {
       return failed2("EIO", "sudo: the rule could not be recorded");
     }
     return grant();
   }
-  listed(self, root, rules, defaults2) {
+  async listed(self, root, rules, defaults2) {
     const host = this.o.hostname;
     if (root) {
       return {
@@ -20566,7 +20654,9 @@ var Sudo = class {
     if (rules.length === 0) {
       return failed2("EPERM", `User ${self.name} is not allowed to run sudo on ${host}.`);
     }
-    const lines2 = rules.map(described).join("\n");
+    const shown2 = [];
+    for (const rule of rules) shown2.push(described(rule, await this.writable(rule)));
+    const lines2 = shown2.join("\n");
     const params = defaults2.flatMap((d) => d.params).join(", ");
     const matching = params === "" ? "" : `Matching Defaults entries for ${self.name} on ${host}:
     ${params}
@@ -20599,9 +20689,10 @@ ${lines2}
       ...caller.tty ? { tty: caller.tty } : {},
       createdAt,
       expiresAt: createdAt + timeout,
-      always: asked.validate ? false : recordable(cwd, [path, ...argv]),
+      always: asked.validate ? false : recordable(cwd, [path, ...argv, ...Object.keys(asked.bound)]),
       stdin: caller.stdin,
       rootOnly: asked.validate ? {} : await this.rootOnly(cwd, argv.slice(1)),
+      ...userWritable(asked.bound),
       ...asked.validate ? { validate: true } : {},
       timestamp: true
     };
@@ -20621,7 +20712,7 @@ ${lines2}
       requester.removeEventListener("abort", withdraw);
     }
   }
-  async remember(self, target, cwd, argv) {
+  async remember(self, target, { cwd, argv, bound: bound3 }) {
     const { fs } = this.o;
     const path = `${SUDOERS_D}/${self.name}`;
     if (!NAME4.test(self.name)) return false;
@@ -20632,7 +20723,7 @@ ${lines2}
       if (st && !await this.trusted(path)) return false;
       const old = st ? await fs.readFile(path) : "";
       const words2 = recordedCommand(argv);
-      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Stdin none Cmnd ${words2}
+      const line = `NOPASSWD ${self.name} (${target.name}) Cwd ${quoteWord(cwd)} Stdin none ${sha256Text(bound3)}Cmnd ${words2}
 `;
       const text = old === "" || old.endsWith("\n") ? `${old}${line}` : `${old}
 ${line}`;
@@ -20643,7 +20734,7 @@ ${line}`;
       return false;
     }
   }
-  grant(self, target, cred, argv, file, cwd, term) {
+  grant(self, target, cred, argv, file, cwd, term, files) {
     const env = {
       ...this.o.env(),
       ...userEnv(target, this.o.pnpmHome),
@@ -20656,7 +20747,9 @@ ${line}`;
       SUDO_GID: String(cred.rgid),
       SUDO_COMMAND: [file, ...argv.slice(1)].join(" ")
     };
-    return { grant: { file, argv: [...argv], env, cwd, cred: credOf(target), caller: cred } };
+    return {
+      grant: { file, argv: [...argv], env, cwd, cred: credOf(target), caller: cred, files }
+    };
   }
 };
 
@@ -26885,18 +26978,18 @@ var VfsNodes = class {
     if (id2 !== void 0) this.know(node, id2);
     return node;
   }
-  open(path, pin, writable2 = false, id2, ino) {
+  open(path, pin, writable3 = false, id2, ino) {
     const found = this.named(path, id2);
     const same3 = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
     if (found && !same3) this.orphan(found);
     const node = (same3 ? found : void 0) ?? this.create(path, id2, new VfsNode(this.fs, path, void 0, false, false, pin));
     node.ino ??= ino;
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
-  adopt(path, contents2, dirty, writable2 = false, id2) {
+  adopt(path, contents2, dirty, writable3 = false, id2) {
     let node = this.named(path, id2);
     if (!node) {
       node = this.create(path, id2, new VfsNode(this.fs, path, contents2, false, dirty));
@@ -26904,7 +26997,7 @@ var VfsNodes = class {
       node.replace(contents2);
     }
     node.opens++;
-    if (writable2) node.writers++;
+    if (writable3) node.writers++;
     if (node.opens === 1) this.opened?.(node);
     return node;
   }
@@ -26917,11 +27010,11 @@ var VfsNodes = class {
       if (node.writers > 0 && within9(path, prefix)) return true;
     return false;
   }
-  closed(node, writable2 = false) {
+  closed(node, writable3 = false) {
     node.opens--;
-    if (writable2) node.writers--;
+    if (writable3) node.writers--;
     if (node.opens > 0) {
-      if (writable2 && node.writers === 0) this.onClosed?.(node.path);
+      if (writable3 && node.writers === 0) this.onClosed?.(node.path);
       return;
     }
     this.forget(node);
@@ -27240,8 +27333,8 @@ function keepingOpen(fs, nodes, changed = () => {
 function vfsFile(fs, opts, nodes) {
   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, opts.ino);
+  const writable3 = 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, writable3, opts.id) : nodes.open(opts.path, opts.pin, writable3, opts.id, opts.ino);
   let openError;
   const atOpen = (op) => {
     void node.serial(op).catch((err) => {
@@ -27268,7 +27361,7 @@ function vfsFile(fs, opts, nodes) {
       offset += out.length;
       return out;
     }) : void 0,
-    write: writable2 ? (bytes) => serial(async () => {
+    write: writable3 ? (bytes) => serial(async () => {
       if (opts.flags & O_APPEND) offset = await node.append(bytes);
       else offset += await node.pwrite(bytes, offset);
       return bytes.length;
@@ -27287,11 +27380,11 @@ function vfsFile(fs, opts, nodes) {
       return node.pread(max, at);
     }),
     pwrite: (bytes, at) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.pwrite(bytes, at);
     }),
     resize: (size) => serial(() => {
-      if (!writable2) throw new KernelError("EBADF");
+      if (!writable3) throw new KernelError("EBADF");
       return node.truncate(size);
     }),
     stat: () => serial(async () => ({
@@ -27307,7 +27400,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node, writable2);
+        nodes?.closed(node, writable3);
       }
     })
   });
@@ -28983,14 +29076,20 @@ var WasmProcess = class {
     if (!("grant" in answer2)) return answer2;
     if (this.dying) throw new KernelError("EINTR");
     if (answer2.notice !== void 0) await this.complainLine(answer2.notice);
-    const { file, argv, env, cwd, cred, caller } = answer2.grant;
+    const { file, argv, env, cwd, cred, caller, files } = answer2.grant;
     const stdio = [{ fd: 0 }, { fd: 1 }, { fd: 2 }];
-    return {
-      pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
-        cred,
-        caller
-      })
-    };
+    try {
+      return {
+        pid: await this.children.spawn({ file, argv, env, cwd, pgid: 0 }, stdio, [], {
+          cred,
+          caller,
+          files
+        })
+      };
+    } catch (err) {
+      if (err instanceof ChangedError) return { error: err.notice, errno: err.code };
+      throw err;
+    }
   }
   stdinKind() {
     if (!this.fds.has(0)) return "none";
@@ -29030,8 +29129,8 @@ var WasmProcess = class {
   };
   withDl(state) {
     if (this.dlLog.length === 0) return state;
-    const { next: next3, handle, free, live } = this.closures;
-    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live] };
+    const { next: next3, handle, free, live: live2 } = this.closures;
+    const dl = { log: [...this.dlLog], next: next3, handle, free: [...free], live: [...live2] };
     return { ...state, dl };
   }
   seedDl(dl) {
@@ -32255,7 +32354,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     if (remote.client.token === remote.token && !remote.client.gone) return remote;
     throw fsError2("ESTALE", "the folder was granted again, so this open file is gone");
   };
-  const live = (fh) => {
+  const live2 = (fh) => {
     const remote = handles.get(fh);
     if (!remote) throw fsError2("EBADF", `handle ${fh}`);
     return fresh3(remote);
@@ -32274,7 +32373,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     }, againMs);
     timer.unref?.();
   });
-  async function writable2(client, path, flags2) {
+  async function writable3(client, path, flags2) {
     const { ifMatch: _, ...asked } = flags2;
     const opening2 = () => client.call("open", { path: rel(path), ...asked });
     try {
@@ -32305,7 +32404,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     async open(path, flags2) {
       const client = current();
       const token = client.token;
-      const { opened: opened2, restore } = await writable2(client, path, flags2);
+      const { opened: opened2, restore } = await writable3(client, path, flags2);
       if (flags2.ifMatch !== void 0 && opened2.attr?.etag !== flags2.ifMatch) {
         await client.call("release", { fh: opened2.fh }, true);
         throw fsError2("ESTALE", `${path} changed on the host while it was being read`);
@@ -32320,7 +32419,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       return nextFh;
     },
     async read(fh, offset, size) {
-      const remote = live(fh);
+      const remote = live2(fh);
       return remote.client.read(
         remote.fh,
         offset,
@@ -32329,7 +32428,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       );
     },
     async write(fh, offset, bytes) {
-      const remote = live(fh);
+      const remote = live2(fh);
       const most = remote.client.maxIo;
       for (let at = 0; at < bytes.length; at += most) {
         await remote.client.write(remote.fh, offset + at, bytes.subarray(at, at + most));
@@ -33569,6 +33668,10 @@ function describe(req, tty) {
   };
   return { argv: [req.argv0, ...req.args], tty, started: Date.now(), ...exe };
 }
+function refuseChanged(approved, now) {
+  const changed = changedFile(approved, now);
+  if (changed !== void 0) throw new ChangedError(changedText(changed));
+}
 function linksOf2(req) {
   return req.links === void 0 ? {} : { links: req.links };
 }
@@ -34702,6 +34805,27 @@ var Launcher = class {
     }
     return true;
   }
+  async unchanged(planned, file, cwd, grant) {
+    const approved = grant?.files;
+    if (!approved) return {};
+    const files = await this.backingOf(planned, file, cwd, "");
+    refuseChanged(approved, await this.sudoer.digests([file, ...files]));
+    return { pinned: approved };
+  }
+  async pinOf(path, caller) {
+    const { pinned: pinned2 } = caller;
+    if (!pinned2) return {};
+    const real = await this.sudoer.real(path);
+    const hex4 = pinned2[real];
+    if (hex4 !== void 0) return { [real]: hex4 };
+    if (await this.sudoer.trusted(real)) return {};
+    throw new ChangedError(changedText(real));
+  }
+  async pinnedBytes(pin, bytes) {
+    const [real = ""] = Object.keys(pin);
+    refuseChanged(pin, { [real]: await sha256(bytes) });
+    return bytes;
+  }
   async grantedCwd(caller, cwd) {
     const real = await physicalPathAsync(this.base, cwd).catch(() => void 0);
     return real === cwd && await this.sudoer.reachable(caller, cwd);
@@ -34790,13 +34914,19 @@ var Launcher = class {
     return found;
   }
   async module(path, caller, asked) {
-    const key = await this.cacheKey(path, asked);
+    const pin = await this.pinOf(path, caller);
+    const sum = Object.values(pin)[0];
+    const key = sum === void 0 ? await this.cacheKey(path, asked) : `${path}:sha256:${sum}`;
     return this.cached(this.compiled, key, async () => {
-      const { bytes, key: read } = await this.keyed(path, caller, asked);
+      const { bytes: read, key: readKey } = await this.keyed(path, caller, asked);
+      const bytes = sum === void 0 ? read : await this.pinnedBytes(pin, read);
       const memory = importedMemory(bytes);
       const foreign = foreignImports(bytes);
       const compiled = await WebAssembly.compile(bytes);
-      return { value: { module: compiled, ...memory ? { memory } : {}, foreign }, key: read };
+      return {
+        value: { module: compiled, ...memory ? { memory } : {}, foreign },
+        key: sum === void 0 ? readKey : key
+      };
     });
   }
   async checkedSources(planned, caller) {
@@ -34821,6 +34951,11 @@ var Launcher = class {
     }
   }
   async text(path, caller, asked) {
+    const pin = await this.pinOf(path, caller);
+    if (Object.keys(pin).length > 0) {
+      const { bytes } = await this.keyed(path, caller, asked);
+      return new TextDecoder().decode(await this.pinnedBytes(pin, bytes));
+    }
     if (!this.integrity) return this.base.readFile(path);
     const key = await this.cacheKey(path, asked);
     return this.cached(this.texts, key, async () => {
@@ -35009,7 +35144,12 @@ var Launcher = class {
     const own = env.HOSTNAME;
     if (asked.target.abi === "wasi") env.HOSTNAME = this.hostname;
     const planned = chosen2(asked, env);
-    const caller = { pid: req.ppid ?? 0, uid: req.cred.euid, tag: req.tags?.[0] };
+    const caller = {
+      pid: req.ppid ?? 0,
+      uid: req.cred.euid,
+      tag: req.tags?.[0],
+      pinned: req.pinned
+    };
     if (this.integrity) await this.checkedSources(planned, caller);
     const [program, exeId] = await this.loaded(planned.target, env, caller);
     if (readsEtcHostname(program)) setOrDrop(env, "HOSTNAME", own);
@@ -35524,6 +35664,7 @@ var Launcher = class {
       const scope = grant ? "" : await this.scopeOf(cred.euid);
       const file = booked === void 0 ? req.file : await this.ticketFile(req, fds);
       const planned = await this.checkedPlan({ ...req, file }, { ppid, cred, scope }, fds);
+      const pin = await this.unchanged(planned, file, req.cwd, grant);
       const { recheck, ...redeemed } = await this.redeemed(
         { ...req, file },
         { ppid, cred, scope, booked },
@@ -35535,6 +35676,7 @@ var Launcher = class {
       const replan = () => this.planOrSearch({ ...req, file }, { ppid, cred, scope });
       const again = { ...planned, replan, recheck };
       const handle = await this.launch(again, {
+        ...pin,
         ...deciding ? { decided: deciding.promise } : {},
         cwd: req.cwd,
         cwdFrom: inheritedCwd(req.chdir, this.cwdSlots.get(ppid)),