@ai-ecoverse/slicc-kernel 1.178.1 → 1.178.3

package/dist/node.js

@@ -3709,7 +3709,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
@@ -5004,9 +5004,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));
           })
         );
       },
@@ -5019,8 +5019,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));
             })
           )
         );
@@ -5055,14 +5055,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();
@@ -8294,6 +8294,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 fail3 = () => reject(new KernelError("EINTR"));
@@ -12766,11 +12773,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);
@@ -15259,30 +15266,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;
@@ -15296,6 +15322,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
@@ -15304,8 +15335,10 @@ var SUDOERS_D = "/etc/sudoers.d";
 var NAME3 = /^[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*/;
@@ -15314,7 +15347,7 @@ var PLAIN = /^[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;
@@ -15481,6 +15514,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}'`;
@@ -15488,19 +15538,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" && !NAME3.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: "*" }];
@@ -16130,12 +16183,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) {
@@ -16266,11 +16333,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;
@@ -16461,15 +16530,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(sha2562, () => "");
     }
-    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;
@@ -16514,7 +16599,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);
@@ -16531,14 +16616,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) {
@@ -16547,22 +16631,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;
     });
   }
@@ -16580,7 +16665,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);
@@ -16596,8 +16681,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;
@@ -16608,14 +16693,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 {
@@ -16627,7 +16715,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}
@@ -16660,9 +16750,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
     };
@@ -16682,7 +16773,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 (!NAME3.test(self.name)) return false;
@@ -16693,7 +16784,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}`;
@@ -16704,7 +16795,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),
@@ -16717,7 +16808,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 }
+    };
   }
 };
 
@@ -22789,18 +22882,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 same2 = !found || ino === void 0 || found.ino === void 0 || found.ino === ino;
     if (found && !same2) this.orphan(found);
     const node = (same2 ? 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));
@@ -22808,7 +22901,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;
   }
@@ -22821,11 +22914,11 @@ var VfsNodes = class {
       if (node.writers > 0 && within7(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);
@@ -23144,8 +23237,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) => {
@@ -23172,7 +23265,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;
@@ -23191,11 +23284,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 () => ({
@@ -23211,7 +23304,7 @@ function vfsFile(fs, opts, nodes) {
         takeOpenError();
         await node.flush();
       } finally {
-        nodes?.closed(node, writable2);
+        nodes?.closed(node, writable3);
       }
     })
   });
@@ -24887,14 +24980,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";
@@ -24934,8 +25033,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) {
@@ -26153,8 +26252,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;
@@ -28362,11 +28461,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
@@ -28374,15 +28473,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 isHandle(child) {
@@ -29464,21 +29563,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);
         });
@@ -29530,19 +29629,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);
@@ -30267,7 +30366,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;
@@ -30286,11 +30385,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 {
@@ -30379,10 +30478,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;
     }
@@ -31094,7 +31193,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);
@@ -31113,7 +31212,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 {
@@ -31144,7 +31243,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`);
@@ -31159,7 +31258,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,
@@ -31168,7 +31267,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));
@@ -32466,6 +32565,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 };
 }
@@ -33599,6 +33702,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 sha2562(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);
@@ -33687,13 +33811,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) {
@@ -33718,6 +33848,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 () => {
@@ -33906,7 +34041,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);
@@ -34421,6 +34561,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 },
@@ -34432,6 +34573,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)),
@@ -37132,7 +37274,7 @@ function dialStream(port, onClose) {
     else finish(errorWithCode(data.error));
   });
   port.start?.();
-  const writable2 = new WritableStream({
+  const writable3 = new WritableStream({
     write(chunk2) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
       const copy = fresh(chunk2);
@@ -37151,7 +37293,7 @@ function dialStream(port, onClose) {
     shut();
     finish(error);
   };
-  return { readable: readable2, writable: writable2, close, fail: fail3 };
+  return { readable: readable2, writable: writable3, close, fail: fail3 };
 }
 
 // src/client/loopback-fetch.ts
@@ -37577,10 +37719,10 @@ function endedOf(done4, signal) {
 async function runOn(channel, argv, opts) {
   const { onStdout, onStderr, ...rest2 } = opts;
   const chunks2 = { 1: [], 2: [] };
-  const live = { 1: new TextDecoder(), 2: new TextDecoder() };
+  const live2 = { 1: new TextDecoder(), 2: new TextDecoder() };
   const tee = (fd, on) => (bytes) => {
     chunks2[fd].push(bytes);
-    on?.(live[fd].decode(bytes, { stream: true }));
+    on?.(live2[fd].decode(bytes, { stream: true }));
   };
   const child = await spawnOn(channel, argv, {
     ...rest2,
@@ -37795,7 +37937,7 @@ var TERMINATED = "the kernel is terminated";
 var EXIT_GRACE_MS = 50;
 var WARM_IDLE_MS = 3e4;
 var MAX_WARM_WORKERS = 64;
-function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
+function warmPool(make, live2, idleMs = WARM_IDLE_MS, size = 1) {
   const spares = [];
   let idle2;
   let closed = false;
@@ -37805,7 +37947,7 @@ function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
     spares.splice(at, 1);
     if (spares.length > 0) return;
     clearTimeout(idle2);
-    live.delete(kill);
+    live2.delete(kill);
   };
   const kill = () => {
     for (const worker of [...spares]) {
@@ -37826,7 +37968,7 @@ function warmPool(make, live, idleMs = WARM_IDLE_MS, size = 1) {
       worker.once("error", () => drop(worker));
       worker.once("exit", () => drop(worker));
       spares.push(worker);
-      live.add(kill);
+      live2.add(kill);
     }
     clearTimeout(idle2);
     idle2 = setTimeout(kill, idleMs);
@@ -37899,12 +38041,12 @@ function sourceModule(source) {
   return { url, source, revoke: () => {
   } };
 }
-function warmPoolOf(options, file, workerData, live) {
+function warmPoolOf(options, file, workerData, live2) {
   const size = sparesOf(options);
   if (size === 0) return void 0;
-  return warmPool(() => processWorker(file, workerData, true), live, WARM_IDLE_MS, size);
+  return warmPool(() => processWorker(file, workerData, true), live2, WARM_IDLE_MS, size);
 }
-function nodeWorker(file, live, closed, workerData, take, internals = false) {
+function nodeWorker(file, live2, closed, workerData, take, internals = false) {
   const errors = /* @__PURE__ */ new Set();
   const messages = /* @__PURE__ */ new Map();
   const fail3 = (message3) => {
@@ -37921,9 +38063,9 @@ function nodeWorker(file, live, closed, workerData, take, internals = false) {
       void worker.terminate();
       fail3(TERMINATED);
     };
-    live.add(kill);
+    live2.add(kill);
     worker.once("exit", (code) => {
-      live.delete(kill);
+      live2.delete(kill);
       setTimeout(() => {
         if (!ending) fail3(`the process worker exited with ${code}`);
       }, EXIT_GRACE_MS);
@@ -38080,23 +38222,23 @@ async function createNodeKernel(options = {}) {
   const root = options.root ?? memoryRoot();
   const fs = new OpfsFs(root, void 0, void 0, { ranged: isMemoryRoot(root) });
   await fs.reconcile();
-  const live = /* @__PURE__ */ new Set();
+  const live2 = /* @__PURE__ */ new Set();
   const pending = /* @__PURE__ */ new Set();
   const clients = /* @__PURE__ */ new Set();
   let terminated = false;
   const file = options.worker ?? new URL("./node-process-worker.cjs", import.meta.url);
   const cache = cacheDirOf(options.compileCache);
   const workerData = cacheData(cache);
-  const warm = warmPoolOf(options, file, workerData, live);
+  const warm = warmPoolOf(options, file, workerData, live2);
   const transport = options.network?.transport;
   const launcher = new Launcher({
     fs,
     moduleUrl: sourceModule,
     unlinkOwner: pidOwner(process),
-    createWorker: () => nodeWorker(file, live, terminated, workerData, warm ? () => warm.take() : void 0, true),
+    createWorker: () => nodeWorker(file, live2, terminated, workerData, warm ? () => warm.take() : void 0, true),
     createDriverWorker: () => nodeWorker(
       options.driverWorker ?? new URL("./node-driver-worker.js", import.meta.url),
-      live,
+      live2,
       terminated
     ),
     ...options.modules ? { modules: options.modules } : {},
@@ -38227,7 +38369,7 @@ async function createNodeKernel(options = {}) {
       warm?.close();
       for (const client of [...clients]) client.detach();
       for (const reject of [...pending]) reject(new Error(TERMINATED));
-      for (const kill of [...live]) kill();
+      for (const kill of [...live2]) kill();
       launcher.cdp.close();
       launcher.endFills();
       launcher.unmountAll();