@jigging/jig 0.1.0-alpha.24 → 0.1.0-alpha.26

package/libexec/macos-native-supervisor.js

@@ -0,0 +1,2216 @@
+// @bun
+// src/internal/macos-native-supervisor.ts
+import { connect } from "net";
+import { dirname as dirname4, join as join6 } from "path";
+import { Transform } from "stream";
+
+// src/internal/macos-control-channel.ts
+function privateMacosControlChannel(socket) {
+  const messages = [];
+  let buffer = Buffer.alloc(0);
+  let ended = false;
+  let failure;
+  let pending;
+  const fail = (reason) => {
+    failure ??= new Error(`macOS control channel ${reason}`);
+    ended = true;
+    messages.length = 0;
+    pending?.reject(failure);
+    pending = undefined;
+    socket.destroy();
+  };
+  const end = () => {
+    if (buffer.length !== 0)
+      return fail("truncated");
+    ended = true;
+    failure ??= new Error("macOS control channel ended");
+    pending?.reject(failure);
+    pending = undefined;
+  };
+  socket.on("data", (data) => {
+    try {
+      if (ended)
+        return fail("socket failed");
+      if (buffer.length + data.length > 65536)
+        return fail("capacity exceeded");
+      buffer = Buffer.concat([buffer, data]);
+      for (;; ) {
+        const newline = buffer.indexOf(10);
+        if (newline < 0)
+          break;
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, newline));
+        buffer = buffer.subarray(newline + 1);
+        const message = JSON.parse(text);
+        if (messages.length >= 8)
+          return fail("capacity exceeded");
+        if (pending !== undefined) {
+          const waiter = pending;
+          pending = undefined;
+          waiter.resolve(message);
+        } else
+          messages.push(message);
+      }
+    } catch {
+      fail("malformed");
+    }
+  });
+  socket.on("error", () => fail("socket failed"));
+  socket.on("end", end);
+  socket.on("close", end);
+  return Object.freeze({
+    receive() {
+      if (messages.length)
+        return Promise.resolve(messages.shift());
+      if (failure !== undefined)
+        return Promise.reject(failure);
+      if (pending !== undefined)
+        return Promise.reject(new Error("concurrent macOS control readers"));
+      return new Promise((resolve, reject) => {
+        pending = { resolve, reject };
+      });
+    },
+    send(value) {
+      const bytes = Buffer.from(`${JSON.stringify(value)}
+`);
+      if (ended || bytes.length > 65536 || socket.writableLength + bytes.length > 65536)
+        throw new Error("macOS control delivery unavailable");
+      socket.write(bytes);
+    },
+    close: () => socket.destroy()
+  });
+}
+async function privateMacosBefore(promise, milliseconds) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("macOS control deadline expired")), Math.max(1, milliseconds));
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/internal/macos-descriptor-handoff.ts
+import { closeSync as closeSync3, constants as constants3, fstatSync as fstatSync2, lstatSync as lstatSync3, realpathSync as realpathSync3 } from "fs";
+import { open as open2 } from "fs/promises";
+import { createRequire as createRequire3 } from "module";
+import { join as join3 } from "path";
+import { getSystemErrorName as getSystemErrorName2 } from "util";
+
+// src/internal/macos-descriptor-files.ts
+import { closeSync as closeSync2, constants as constants2, readFileSync, realpathSync as realpathSync2, lstatSync as lstatSync2 } from "fs";
+import { createHash } from "crypto";
+import { fileURLToPath } from "url";
+import { mkdtemp, open, rmdir } from "fs/promises";
+import { createRequire as createRequire2 } from "module";
+import { join as join2, dirname as dirname2 } from "path";
+import { getSystemErrorName } from "util";
+
+// src/internal/macos-process-controls.ts
+import { createRequire } from "module";
+import { release } from "os";
+
+// src/internal/macos-owner-state.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import {
+  closeSync,
+  constants,
+  fstatSync,
+  fsyncSync,
+  lstatSync,
+  openSync,
+  readSync,
+  realpathSync,
+  rmdirSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, join, posix } from "path";
+var O_NOFOLLOW_ANY = 536870912;
+var O_CLOEXEC = 16777216;
+var handles = new WeakMap;
+var tokenPattern = /^[0-9a-f]{64}$/;
+function privateMacosStorageRecoveryToken(token) {
+  if (!tokenPattern.test(token))
+    throw new TypeError("invalid macOS ownership token");
+  return createHmac("sha256", Buffer.from(token, "hex")).update("jig-macos-storage-recovery").digest("hex");
+}
+function privateDirectory(path) {
+  if (process.platform !== "darwin" || !path.startsWith("/") || realpathSync(path) !== path)
+    throw new Error("macOS ownership requires a canonical protected directory");
+  const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | O_NOFOLLOW_ANY | O_CLOEXEC);
+  const stat = fstatSync(fd);
+  if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0) {
+    closeSync(fd);
+    throw new Error("macOS ownership directory is not private");
+  }
+  return fd;
+}
+function requirePrivateMacosOwnerDirectory(path) {
+  closeSync(privateDirectory(path));
+}
+function signature(token, identity, domain = "jig-macos-owner") {
+  if (!tokenPattern.test(token))
+    throw new TypeError("invalid macOS ownership token");
+  return createHmac("sha256", Buffer.from(token, "hex")).update(`${domain}\x00`).update(JSON.stringify(identity)).digest();
+}
+function recordPrivateMacosOwner(directory, token, control) {
+  const owner = requirePrivateMacosCoalition(control);
+  if (!owner.empty())
+    throw new Error("macOS ownership must be durable before creating descendants");
+  const identity = owner.identity;
+  const mac = signature(token, identity).toString("hex");
+  const parent = privateDirectory(directory);
+  let fd;
+  try {
+    fd = openSync(join(directory, "owner.json"), constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | O_NOFOLLOW_ANY | O_CLOEXEC, 384);
+    writeFileSync(fd, `${JSON.stringify({ identity, mac })}
+`);
+    fsyncSync(fd);
+    fsyncSync(parent);
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+    closeSync(parent);
+  }
+  return readPrivateMacosOwner(directory, token);
+}
+function readRecord(directory, name) {
+  const parent = privateDirectory(directory);
+  let fd;
+  try {
+    fd = openSync(join(directory, name), constants.O_RDONLY | O_NOFOLLOW_ANY | O_CLOEXEC);
+    const before = fstatSync(fd, { bigint: true });
+    if (!before.isFile() || before.uid !== BigInt(process.getuid?.() ?? -1) || (before.mode & 0o177n) !== 0n || before.nlink !== 1n || before.size < 1n || before.size > 1024n)
+      throw new Error("macOS ownership journal is unsafe");
+    const buffer = Buffer.alloc(1025);
+    let count = 0;
+    while (count < buffer.length) {
+      const read = readSync(fd, buffer, count, buffer.length - count, count);
+      if (read === 0)
+        break;
+      count += read;
+    }
+    if (BigInt(count) !== before.size)
+      throw new Error("macOS ownership journal size changed");
+    const bytes = buffer.subarray(0, count);
+    const after = fstatSync(fd, { bigint: true });
+    if (before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs || after.nlink !== 1n)
+      throw new Error("macOS ownership journal changed");
+    const record = JSON.parse(bytes.toString("utf8"));
+    if (record === null || typeof record !== "object" || Object.keys(record).sort().join() !== "identity,mac")
+      throw new Error("invalid macOS ownership journal");
+    return record;
+  } finally {
+    if (fd !== undefined)
+      closeSync(fd);
+    closeSync(parent);
+  }
+}
+function readPrivateMacosOwner(directory, token) {
+  if (!tokenPattern.test(token))
+    throw new TypeError("invalid macOS ownership token");
+  const record = readRecord(directory, "owner.json");
+  const raw = record.identity;
+  if (raw === null || typeof raw !== "object" || Object.keys(raw).sort().join() !== "bootId,coalition,guardianPid,guardianVersion" || typeof raw.bootId !== "string" || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/.test(raw.bootId) || typeof raw.coalition !== "string" || !/^[1-9][0-9]{0,19}$/.test(raw.coalition) || BigInt(raw.coalition) > 0xffffffffffffffffn || !Number.isSafeInteger(raw.guardianPid) || raw.guardianPid <= 1 || raw.guardianPid > 2147483647 || !Number.isSafeInteger(raw.guardianVersion) || raw.guardianVersion < 0 || raw.guardianVersion > 4294967295 || typeof record.mac !== "string" || !tokenPattern.test(record.mac))
+    throw new Error("invalid macOS ownership identity");
+  const identity = Object.freeze({
+    bootId: raw.bootId,
+    coalition: raw.coalition,
+    guardianPid: raw.guardianPid,
+    guardianVersion: raw.guardianVersion
+  });
+  if (!timingSafeEqual(signature(token, identity), Buffer.from(record.mac, "hex")))
+    throw new Error("macOS ownership authentication failed");
+  const handle = Object.freeze({ identity });
+  handles.set(handle, identity);
+  return handle;
+}
+
+// src/internal/macos-process-controls.ts
+var PROC_PIDUNIQIDENTIFIERINFO = 17;
+var PROC_PIDCOALITIONINFO = 20;
+var RESOURCE_USAGE_BYTES = 37 * 8;
+var MAX_PROCESSES = 65536;
+var signals = Object.freeze({ stop: 17, continue: 19, kill: 9 });
+var native;
+var authenticCoalitions = new WeakSet;
+function calls() {
+  if (native !== undefined)
+    return native;
+  if (process.platform !== "darwin" || !["x64", "arm64"].includes(process.arch))
+    throw new Error("macOS process controls are not qualified on this kernel");
+  const ffi = createRequire(import.meta.url)("bun:ffi");
+  const library = ffi.dlopen("/usr/lib/libSystem.B.dylib", {
+    coalition_info_resource_usage: { args: ["u64", "ptr", "u64"], returns: "i32" },
+    mach_timebase_info: { args: ["ptr"], returns: "i32" },
+    proc_pidinfo: { args: ["i32", "i32", "u64", "ptr", "i32"], returns: "i32" },
+    proc_listallpids: { args: ["ptr", "i32"], returns: "i32" },
+    proc_pid_rusage: { args: ["i32", "i32", "ptr"], returns: "i32" },
+    proc_signal_with_audittoken: { args: ["ptr", "i32"], returns: "i32" },
+    sysctlbyname: { args: ["ptr", "ptr", "ptr", "ptr", "u64"], returns: "i32" },
+    getsockopt: { args: ["i32", "i32", "i32", "ptr", "ptr"], returns: "i32" },
+    __error: { args: [], returns: "ptr" }
+  });
+  const timebase = Buffer.alloc(8);
+  if (library.symbols.mach_timebase_info(ffi.ptr(timebase)) !== 0 || timebase.readUInt32LE(0) === 0 || timebase.readUInt32LE(4) === 0)
+    throw new Error("macOS CPU timebase is unavailable");
+  const opened = {
+    ptr: ffi.ptr,
+    read: ffi.read,
+    symbols: library.symbols,
+    timeNumerator: BigInt(timebase.readUInt32LE(0)),
+    timeDenominator: BigInt(timebase.readUInt32LE(4))
+  };
+  if (!platformFor(kernelString(opened, "kern.osversion")))
+    throw new Error("macOS process controls are not qualified on this kernel build");
+  native = opened;
+  return native;
+}
+function privateMacosPeerIdentity(socket) {
+  const fd = socket._handle?.fd;
+  if (socket.destroyed || fd === undefined || !Number.isSafeInteger(fd) || fd < 0)
+    throw new Error("macOS control socket descriptor is unavailable");
+  return privateMacosDescriptorPeerIdentity(fd);
+}
+function privateMacosDescriptorPeerIdentity(fd) {
+  if (!Number.isSafeInteger(fd) || fd < 0)
+    throw new Error("macOS control socket descriptor is unavailable");
+  const { ptr, symbols } = calls();
+  const token = Buffer.alloc(32);
+  const length = Buffer.alloc(4);
+  length.writeUInt32LE(token.length);
+  if (symbols.getsockopt(fd, 0, 6, ptr(token), ptr(length)) !== 0 || length.readUInt32LE() !== 32)
+    throw new Error("macOS control peer identity is unavailable");
+  return Object.freeze({
+    uid: token.readUInt32LE(4),
+    realUid: token.readUInt32LE(12),
+    pid: token.readUInt32LE(20),
+    version: token.readUInt32LE(28)
+  });
+}
+function kernelString(native2, key) {
+  const name = Buffer.from(`${key}\x00`);
+  const bytes = Buffer.alloc(64);
+  const size = Buffer.alloc(8);
+  size.writeBigUInt64LE(BigInt(bytes.length));
+  if (native2.symbols.sysctlbyname(native2.ptr(name), native2.ptr(bytes), native2.ptr(size), 0, 0) !== 0)
+    throw new Error("macOS kernel identity is unavailable");
+  const length = size.readBigUInt64LE();
+  const end = bytes.indexOf(0);
+  if (length < 1n || length > 64n || end !== Number(length) - 1)
+    throw new Error("macOS kernel identity is invalid");
+  return bytes.subarray(0, end).toString("ascii");
+}
+function processIdentity(pid) {
+  const { ptr, symbols } = calls();
+  const unique = Buffer.alloc(56);
+  const coalitions = Buffer.alloc(40);
+  if (symbols.proc_pidinfo(pid, PROC_PIDUNIQIDENTIFIERINFO, 0, ptr(unique), 56) !== 56)
+    return;
+  if (symbols.proc_pidinfo(pid, PROC_PIDCOALITIONINFO, 0, ptr(coalitions), 40) !== 40)
+    return;
+  return { version: unique.readUInt32LE(32), coalition: coalitions.readBigUInt64LE(0) };
+}
+function bootIdentity() {
+  const result = kernelString(calls(), "kern.bootsessionuuid");
+  if (!/^[0-9A-Fa-f]{8}(?:-[0-9A-Fa-f]{4}){3}-[0-9A-Fa-f]{12}$/.test(result))
+    throw new Error("macOS boot identity is invalid");
+  return result.toLowerCase();
+}
+function privateMacosCurrentProcessIdentity() {
+  const identity = processIdentity(process.pid);
+  const uid = process.getuid?.();
+  if (identity === undefined || uid === undefined || uid === 0)
+    throw new Error("macOS coordinator identity is unavailable");
+  return Object.freeze({ uid, pid: process.pid, version: identity.version });
+}
+function usage(coalition, absentIsEmpty = false) {
+  const { ptr, read, symbols } = calls();
+  const bytes = Buffer.alloc(RESOURCE_USAGE_BYTES);
+  if (symbols.coalition_info_resource_usage(coalition, ptr(bytes), bytes.length) !== 0) {
+    if (read.i32(symbols.__error()) === 3 && absentIsEmpty)
+      return { active: 0n, cpuNanoseconds: 0n };
+    throw new Error("macOS coalition accounting is unavailable");
+  }
+  const started = bytes.readBigUInt64LE(0);
+  const exited = bytes.readBigUInt64LE(8);
+  if (started < exited)
+    throw new Error("macOS coalition accounting is invalid");
+  const timebase = calls();
+  return {
+    active: started - exited,
+    cpuNanoseconds: bytes.readBigUInt64LE(24) * timebase.timeNumerator / timebase.timeDenominator
+  };
+}
+function coalitionMembers(coalition, exclude) {
+  const { ptr, symbols } = calls();
+  const bytes = Buffer.alloc(MAX_PROCESSES * 4);
+  const count = symbols.proc_listallpids(ptr(bytes), bytes.length);
+  if (count < 1 || count >= MAX_PROCESSES)
+    throw new Error("macOS process enumeration is incomplete");
+  const result = [];
+  for (let index = 0;index < count; index++) {
+    const candidate = bytes.readInt32LE(index * 4);
+    if (candidate <= 1 || candidate === exclude)
+      continue;
+    const observed = processIdentity(candidate);
+    if (observed?.coalition === coalition)
+      result.push({ pid: candidate, version: observed.version });
+  }
+  return result;
+}
+function signalMembers(members, signal) {
+  if (!Object.hasOwn(signals, signal))
+    throw new TypeError("invalid macOS ownership signal");
+  const { ptr, read, symbols } = calls();
+  let count = 0;
+  for (const member of members) {
+    const token = Buffer.alloc(32);
+    token.writeUInt32LE(member.pid, 20);
+    token.writeUInt32LE(member.version, 28);
+    const result = symbols.proc_signal_with_audittoken(ptr(token), signals[signal]);
+    if (result !== 0 && read.i32(symbols.__error()) !== 3)
+      throw new Error("macOS owned process signaling failed");
+    if (result === 0)
+      count++;
+  }
+  return count;
+}
+function requirePrivateMacosCoalition(value) {
+  if (value === null || typeof value !== "object" || !authenticCoalitions.has(value))
+    throw new TypeError("macOS coalition control is not authentic");
+  return value;
+}
+function acquirePrivateMacosCoalition() {
+  const pid = process.pid;
+  const owner = processIdentity(pid);
+  if (owner === undefined || owner.coalition === 0n || usage(owner.coalition).active !== 1n)
+    throw new Error("macOS guardian requires an exclusive resource coalition");
+  const identity = Object.freeze({
+    bootId: bootIdentity(),
+    coalition: owner.coalition.toString(),
+    guardianPid: pid,
+    guardianVersion: owner.version
+  });
+  const validateOwner = () => {
+    const current = processIdentity(process.pid);
+    if (process.pid !== pid || current?.coalition !== owner.coalition || current.version !== owner.version)
+      throw new Error("macOS guardian identity changed");
+  };
+  const members = () => {
+    validateOwner();
+    return coalitionMembers(owner.coalition, pid);
+  };
+  const control = Object.freeze({
+    identity,
+    contains(pid2, version) {
+      validateOwner();
+      if (!Number.isSafeInteger(pid2) || pid2 <= 1 || !Number.isSafeInteger(version) || version < 0)
+        return false;
+      const current = processIdentity(pid2);
+      return current?.version === version && current.coalition === owner.coalition;
+    },
+    sample() {
+      const start = performance.now();
+      validateOwner();
+      const before = usage(owner.coalition);
+      const { ptr, symbols } = calls();
+      let footprintBytes = 0n;
+      let observedMembers = 0;
+      let complete = true;
+      for (const member of members()) {
+        const bytes = Buffer.alloc(96);
+        const read = symbols.proc_pid_rusage(member.pid, 0, ptr(bytes));
+        const after2 = processIdentity(member.pid);
+        if (read !== 0 || after2?.version !== member.version || after2.coalition !== owner.coalition) {
+          complete = false;
+          continue;
+        }
+        footprintBytes += bytes.readBigUInt64LE(72);
+        observedMembers++;
+      }
+      const after = usage(owner.coalition);
+      if (after.cpuNanoseconds < before.cpuNanoseconds)
+        throw new Error("macOS CPU accounting moved backwards");
+      return Object.freeze({
+        ...after,
+        footprintBytes,
+        observedMembers,
+        complete: complete && before.active === after.active && after.active === BigInt(observedMembers + 1),
+        sampleMilliseconds: performance.now() - start
+      });
+    },
+    signalMembers(signal) {
+      return signalMembers(members(), signal);
+    },
+    empty() {
+      validateOwner();
+      return usage(owner.coalition).active === 1n;
+    }
+  });
+  authenticCoalitions.add(control);
+  return control;
+}
+function platformFor(build) {
+  if (process.arch === "x64" && release() === "23.4.0" && build === "23E224")
+    return "darwin-x64-23.4.0-23E224";
+  if (release() === "24.6.0" && build === "24G830") {
+    if (process.arch === "x64")
+      return "darwin-x64-24.6.0-24G830";
+    if (process.arch === "arm64")
+      return "darwin-arm64-24.6.0-24G830";
+  }
+}
+
+// src/internal/macos-descriptor-files.ts
+var native2;
+var handleClass;
+var CLOEXEC = 16777216;
+var NOFOLLOW_ANY = 536870912;
+function calls2() {
+  if (native2 !== undefined)
+    return native2;
+  privateMacosCurrentProcessIdentity();
+  if (process.versions.bun !== "1.4.2")
+    throw new Error("macOS descriptor adoption requires the qualified Bun runtime");
+  const ffi = createRequire2(import.meta.url)("bun:ffi");
+  const modulePath = fileURLToPath(import.meta.url);
+  const libexec = modulePath.lastIndexOf("/libexec/");
+  const bridge = libexec >= 0 ? join2(modulePath.slice(0, libexec), "libexec/macos-descriptor-bridge.dylib") : join2(dirname2(modulePath), modulePath.includes("/internal/") ? "../../support/macos-descriptor-bridge.dylib" : "../support/macos-descriptor-bridge.dylib");
+  const canonical = realpathSync2(bridge);
+  const metadata = lstatSync2(bridge);
+  if (canonical !== bridge || !metadata.isFile() || metadata.size > 1024 * 1024 || (metadata.mode & 18) !== 0 || createHash("sha256").update(readFileSync(bridge)).digest("hex") !== "c8418f5bfc1bd2b346eb962c9379605df12f79b6d7395eefb2fde4ff7ded9b4e")
+    throw new Error("native descriptor bridge identity is invalid");
+  const declarations = {
+    openat: { args: ["i32", "ptr", "i32", "u32"], returns: "i32" },
+    fcntl: { args: ["i32", "i32", "u64"], returns: "i32" },
+    fstatat: { args: ["i32", "ptr", "ptr", "i32"], returns: "i32" },
+    fstatfs: { args: ["i32", "ptr"], returns: "i32" },
+    fdopendir: { args: ["i32", "ptr"], returns: "ptr" },
+    readdir: { args: ["ptr", "ptr"], returns: "ptr" },
+    closedir: { args: ["ptr"], returns: "i32" },
+    mkdirat: { args: ["i32", "ptr", "u32"], returns: "i32" },
+    unlinkat: { args: ["i32", "ptr", "i32"], returns: "i32" },
+    renameatx_np: { args: ["i32", "ptr", "i32", "ptr", "u32"], returns: "i32" },
+    readlinkat: { args: ["i32", "ptr", "ptr", "u64"], returns: "i64" },
+    symlinkat: { args: ["ptr", "i32", "ptr"], returns: "i32" },
+    linkat: { args: ["i32", "ptr", "i32", "ptr", "i32"], returns: "i32" }
+  };
+  const fixed = ffi.dlopen(bridge, Object.fromEntries(Object.entries(declarations).map(([name, declaration]) => [`jig_${name}`, declaration])));
+  const symbols = Object.fromEntries(Object.keys(declarations).map((name) => [name, fixed.symbols[`jig_${name}`]]));
+  native2 = { ptr: ffi.ptr, toArrayBuffer: ffi.toArrayBuffer, symbols };
+  return native2;
+}
+function checked(result) {
+  if (result >= 0)
+    return result;
+  const code = getSystemErrorName(result);
+  throw Object.assign(new Error(`macOS descriptor operation failed (${code})`), { code });
+}
+function nameBytes(value) {
+  const bytes = Buffer.from(value);
+  if (!bytes.length || bytes.length > 1023 || bytes.includes(0) || bytes.includes(47) || bytes.equals(Buffer.from(".")) || bytes.equals(Buffer.from("..")))
+    throw new TypeError("descriptor operation requires one leaf name");
+  return Buffer.concat([bytes, Buffer.from([0])]);
+}
+async function handleConstructor() {
+  calls2();
+  handleClass ??= (async () => {
+    const handle = await open("/dev/null", constants2.O_RDONLY | CLOEXEC);
+    try {
+      return handle.constructor;
+    } finally {
+      await handle.close();
+    }
+  })();
+  return handleClass;
+}
+async function privateMacosOpenAt(parent, name, flags, mode = 384) {
+  const Constructor = await handleConstructor();
+  const fd = privateMacosOpenFdAt(parent, name, flags, mode);
+  try {
+    return new Constructor(fd);
+  } catch (error) {
+    closeSync2(fd);
+    throw error;
+  }
+}
+function privateMacosOpenFdAt(parent, name, flags, mode = 384) {
+  const { ptr, symbols } = calls2();
+  const path = nameBytes(name);
+  return checked(symbols.openat(parent, ptr(path), flags & ~constants2.O_NOFOLLOW | CLOEXEC | NOFOLLOW_ANY, mode));
+}
+function privateMacosFcntl(fd, command, value = 0) {
+  return checked(calls2().symbols.fcntl(fd, command, value));
+}
+function privateMacosFilesystem(fd) {
+  const { ptr, symbols } = calls2();
+  const bytes = Buffer.alloc(2168);
+  checked(symbols.fstatfs(fd, ptr(bytes)));
+  const string = (start, size) => {
+    const value = bytes.subarray(start, start + size);
+    const end = value.indexOf(0);
+    if (end < 0)
+      throw new Error("macOS filesystem identity is invalid");
+    return new TextDecoder("utf-8", { fatal: true }).decode(value.subarray(0, end));
+  };
+  return Object.freeze({
+    capacityBytes: BigInt(bytes.readUInt32LE(0)) * bytes.readBigUInt64LE(8),
+    owner: bytes.readUInt32LE(56),
+    flags: bytes.readUInt32LE(64),
+    subtype: bytes.readUInt32LE(68),
+    type: string(72, 16),
+    mountpoint: string(88, 1024),
+    device: string(1112, 1024)
+  });
+}
+function privateMacosStatAt(parent, name) {
+  const { ptr, symbols } = calls2();
+  const path = nameBytes(name), bytes = Buffer.alloc(144);
+  checked(symbols.fstatat(parent, ptr(path), ptr(bytes), 32));
+  const mode = BigInt(bytes.readUInt16LE(4));
+  const atimeNs = bytes.readBigInt64LE(32) * 1000000000n + bytes.readBigInt64LE(40);
+  const mtimeNs = bytes.readBigInt64LE(48) * 1000000000n + bytes.readBigInt64LE(56);
+  const ctimeNs = bytes.readBigInt64LE(64) * 1000000000n + bytes.readBigInt64LE(72);
+  const birthtimeNs = bytes.readBigInt64LE(80) * 1000000000n + bytes.readBigInt64LE(88);
+  const kind = (type) => (mode & 0xf000n) === type;
+  return {
+    dev: BigInt(bytes.readInt32LE(0)),
+    mode,
+    nlink: BigInt(bytes.readUInt16LE(6)),
+    ino: bytes.readBigUInt64LE(8),
+    uid: BigInt(bytes.readUInt32LE(16)),
+    gid: BigInt(bytes.readUInt32LE(20)),
+    rdev: BigInt(bytes.readInt32LE(24)),
+    size: bytes.readBigInt64LE(96),
+    blocks: bytes.readBigInt64LE(104),
+    blksize: BigInt(bytes.readInt32LE(112)),
+    atimeNs,
+    mtimeNs,
+    ctimeNs,
+    birthtimeNs,
+    atimeMs: atimeNs / 1000000n,
+    mtimeMs: mtimeNs / 1000000n,
+    ctimeMs: ctimeNs / 1000000n,
+    birthtimeMs: birthtimeNs / 1000000n,
+    atime: new Date(Number(atimeNs / 1000000n)),
+    mtime: new Date(Number(mtimeNs / 1000000n)),
+    ctime: new Date(Number(ctimeNs / 1000000n)),
+    birthtime: new Date(Number(birthtimeNs / 1000000n)),
+    isFile: () => kind(0x8000n),
+    isDirectory: () => kind(0x4000n),
+    isSymbolicLink: () => kind(0xa000n),
+    isBlockDevice: () => kind(0x6000n),
+    isCharacterDevice: () => kind(0x2000n),
+    isFIFO: () => kind(0x1000n),
+    isSocket: () => kind(0xc000n)
+  };
+}
+function privateMacosDirectory(fd) {
+  const { ptr, symbols, toArrayBuffer } = calls2();
+  const dot = Buffer.from(".\x00");
+  const duplicate = checked(symbols.openat(fd, ptr(dot), constants2.O_RDONLY | constants2.O_DIRECTORY | CLOEXEC | NOFOLLOW_ANY, 0));
+  const error = Buffer.alloc(4);
+  const stream = symbols.fdopendir(duplicate, ptr(error));
+  if (!stream) {
+    const code = error.readInt32LE();
+    closeSync2(duplicate);
+    throw Object.assign(new Error("macOS directory stream unavailable"), {
+      code: getSystemErrorName(-code)
+    });
+  }
+  let closed = false;
+  const read = () => {
+    if (closed)
+      throw new Error("macOS directory stream is closed");
+    for (;; ) {
+      const entry = symbols.readdir(stream, ptr(error));
+      if (!entry) {
+        if (error.readInt32LE() !== 0)
+          checked(-error.readInt32LE());
+        return null;
+      }
+      const header = Buffer.from(toArrayBuffer(entry, 0, 21));
+      const length = header.readUInt16LE(18), recordLength = header.readUInt16LE(16), type = header[20];
+      if (length > 1023 || recordLength < 22 + length || recordLength > 1048)
+        throw new Error("invalid macOS directory entry");
+      const bytes = Buffer.from(new Uint8Array(toArrayBuffer(entry, 21, length + 1)));
+      if (bytes[length] !== 0 || bytes.subarray(0, length).includes(0))
+        throw new Error("invalid macOS directory name");
+      const name = bytes.subarray(0, length);
+      if (name.equals(Buffer.from(".")) || name.equals(Buffer.from("..")))
+        continue;
+      return {
+        name,
+        parentPath: "",
+        isFile: () => type === 8,
+        isDirectory: () => type === 4,
+        isSymbolicLink: () => type === 10,
+        isBlockDevice: () => type === 6,
+        isCharacterDevice: () => type === 2,
+        isFIFO: () => type === 1,
+        isSocket: () => type === 12
+      };
+    }
+  };
+  const close = () => {
+    if (closed)
+      return;
+    closed = true;
+    checked(symbols.closedir(stream));
+  };
+  return {
+    readSync: read,
+    closeSync: close,
+    async read() {
+      return read();
+    },
+    async close() {
+      close();
+    },
+    async* [Symbol.asyncIterator]() {
+      try {
+        for (;; ) {
+          const entry = read();
+          if (entry === null)
+            break;
+          yield entry;
+        }
+      } finally {
+        close();
+      }
+    }
+  };
+}
+function privateMacosMkdirAt(parent, name, mode) {
+  const { ptr, symbols } = calls2(), path = nameBytes(name);
+  checked(symbols.mkdirat(parent, ptr(path), mode));
+}
+function privateMacosUnlinkAt(parent, name, directory = false) {
+  const { ptr, symbols } = calls2(), path = nameBytes(name);
+  checked(symbols.unlinkat(parent, ptr(path), directory ? 128 : 0));
+}
+
+// src/internal/macos-descriptor-handoff.ts
+var MAX_DESCRIPTORS = 64;
+var CONTROL_BYTES = 4096;
+var MAX_WAIT_MS = 1e4;
+var MAGIC = Buffer.from("JFD1");
+var native3;
+function calls3() {
+  if (native3 !== undefined)
+    return native3;
+  privateMacosCurrentProcessIdentity();
+  const ffi = createRequire3(import.meta.url)("bun:ffi");
+  const { symbols } = ffi.dlopen("/usr/lib/libSystem.B.dylib", {
+    socket: { args: ["i32", "i32", "i32"], returns: "i32" },
+    bind: { args: ["i32", "ptr", "u32"], returns: "i32" },
+    listen: { args: ["i32", "i32"], returns: "i32" },
+    accept: { args: ["i32", "ptr", "ptr"], returns: "i32" },
+    connect: { args: ["i32", "ptr", "u32"], returns: "i32" },
+    poll: { args: ["ptr", "u32", "i32"], returns: "i32" },
+    getsockopt: { args: ["i32", "i32", "i32", "ptr", "ptr"], returns: "i32" },
+    sendmsg: { args: ["i32", "ptr", "i32"], returns: "i64" },
+    recvmsg: { args: ["i32", "ptr", "i32"], returns: "i64" },
+    send: { args: ["i32", "ptr", "u64", "i32"], returns: "i64" },
+    recv: { args: ["i32", "ptr", "u64", "i32"], returns: "i64" },
+    shutdown: { args: ["i32", "i32"], returns: "i32" },
+    __error: { args: [], returns: "ptr" }
+  });
+  native3 = { symbols, ptr: ffi.ptr, read: ffi.read };
+  return native3;
+}
+function errno() {
+  const { symbols, read } = calls3();
+  return read.i32(symbols.__error());
+}
+function checked2(value) {
+  if (value >= 0)
+    return value;
+  throw Object.assign(new Error("macOS descriptor handoff operation failed"), {
+    code: getSystemErrorName2(-errno())
+  });
+}
+function socket() {
+  const fd = checked2(calls3().symbols.socket(1, 1, 0));
+  try {
+    configure(fd);
+    return fd;
+  } catch (error) {
+    closeSync3(fd);
+    throw error;
+  }
+}
+function configure(fd) {
+  privateMacosFcntl(fd, 2, 1);
+  privateMacosFcntl(fd, 4, privateMacosFcntl(fd, 3) | 4);
+  if ((privateMacosFcntl(fd, 1) & 1) !== 1 || (privateMacosFcntl(fd, 3) & 4) !== 4)
+    throw new Error("macOS descriptor socket flags are unavailable");
+}
+function address(path) {
+  const encoded = Buffer.from(path);
+  if (!path.startsWith("/") || path.includes("\x00") || encoded.length > 103 || encoded.toString("utf8") !== path)
+    throw new Error("macOS descriptor handoff path is invalid");
+  const bytes = Buffer.alloc(106);
+  bytes[0] = encoded.length + 3;
+  bytes[1] = 1;
+  encoded.copy(bytes, 2);
+  return bytes;
+}
+function authenticate(fd, expected) {
+  if (!Number.isSafeInteger(expected.pid) || expected.pid < 1 || !Number.isSafeInteger(expected.version) || expected.version < 1)
+    throw new Error("macOS descriptor handoff peer is invalid");
+  const actual = privateMacosDescriptorPeerIdentity(fd);
+  if (actual.uid !== process.getuid?.() || actual.realUid !== actual.uid || actual.pid !== expected.pid || actual.version !== expected.version)
+    throw new Error("macOS descriptor handoff peer does not match");
+}
+function budget(timeoutMs, signal) {
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > MAX_WAIT_MS)
+    throw new Error("macOS descriptor handoff deadline is invalid");
+  const deadline = performance.now() + timeoutMs;
+  return async () => {
+    signal?.throwIfAborted();
+    if (performance.now() >= deadline)
+      throw new Error("macOS descriptor handoff timed out");
+    await new Promise((resolve) => setTimeout(resolve, 5));
+    signal?.throwIfAborted();
+  };
+}
+function retry(value) {
+  return value < 0 && [4, 35].includes(errno());
+}
+function message(body, control) {
+  const { ptr } = calls3();
+  const vector = Buffer.alloc(16), header = Buffer.alloc(48);
+  vector.writeBigUInt64LE(BigInt(ptr(body)), 0);
+  vector.writeBigUInt64LE(BigInt(body.length), 8);
+  header.writeBigUInt64LE(BigInt(ptr(vector)), 16);
+  header.writeInt32LE(1, 24);
+  header.writeBigUInt64LE(BigInt(ptr(control)), 32);
+  header.writeUInt32LE(control.length, 40);
+  return { header, vector, body, control };
+}
+var receivedBundles = new WeakMap;
+function requirePrivateMacosReceivedDescriptors(bundle) {
+  const record = bundle !== null && typeof bundle === "object" ? receivedBundles.get(bundle) : undefined;
+  if (record === undefined || record.closed)
+    throw new Error("macOS descriptor bundle is not active");
+  return record.descriptors;
+}
+async function createPrivateMacosDescriptorReceiver(directory, leaf) {
+  privateMacosCurrentProcessIdentity();
+  if (!["inputs", "output", "roots"].includes(leaf))
+    throw new Error("invalid descriptor handoff role");
+  const parent = await open2(directory, constants3.O_RDONLY | constants3.O_DIRECTORY | 536870912 | 16777216);
+  let listener;
+  let identity;
+  let closed = false, receiving = false, consumed = false;
+  const path = join3(directory, `fd-${leaf}`);
+  const name = `fd-${leaf}`;
+  const sameParent = () => {
+    const held = fstatSync2(parent.fd, { bigint: true }), visible = lstatSync3(directory, { bigint: true });
+    if (!held.isDirectory() || held.dev !== visible.dev || held.ino !== visible.ino || held.uid !== BigInt(process.getuid()) || (held.mode & 0o077n) !== 0n || realpathSync3(directory) !== directory)
+      throw new Error("macOS descriptor handoff owner changed");
+  };
+  const close = async () => {
+    if (closed)
+      return;
+    closed = true;
+    try {
+      if (listener !== undefined) {
+        closeSync3(listener);
+        listener = undefined;
+      }
+      if (identity !== undefined) {
+        const entry = privateMacosStatAt(parent.fd, name);
+        if (!entry.isSocket() || entry.dev !== identity.dev || entry.ino !== identity.ino)
+          throw new Error("macOS descriptor handoff socket changed");
+        privateMacosUnlinkAt(parent.fd, name);
+      }
+    } finally {
+      await parent.close();
+    }
+  };
+  try {
+    sameParent();
+    const sockaddr = address(path), { symbols, ptr } = calls3();
+    listener = socket();
+    checked2(symbols.bind(listener, ptr(sockaddr), sockaddr[0]));
+    sameParent();
+    const entry = privateMacosStatAt(parent.fd, name);
+    if (!entry.isSocket() || entry.uid !== BigInt(process.getuid()))
+      throw new Error("macOS descriptor handoff socket is invalid");
+    identity = { dev: entry.dev, ino: entry.ino };
+    checked2(symbols.listen(listener, 1));
+    return Object.freeze({
+      path,
+      close,
+      async receive(peer, timeoutMs, signal) {
+        if (closed || receiving || consumed)
+          throw new Error("macOS descriptor receiver is unavailable");
+        const delay = budget(timeoutMs, signal);
+        const wait = async () => {
+          if (closed)
+            throw new Error("macOS descriptor receiver is closed");
+          await delay();
+          if (closed)
+            throw new Error("macOS descriptor receiver is closed");
+        };
+        receiving = true;
+        let connection;
+        try {
+          for (;; ) {
+            signal?.throwIfAborted();
+            if (closed)
+              throw new Error("macOS descriptor receiver is closed");
+            const accepted = symbols.accept(listener, 0, 0);
+            if (accepted >= 0) {
+              connection = accepted;
+              break;
+            }
+            if (!retry(accepted))
+              checked2(accepted);
+            await wait();
+          }
+          configure(connection);
+          authenticate(connection, peer);
+          consumed = true;
+          return await receive(connection, wait);
+        } finally {
+          if (connection !== undefined)
+            closeSync3(connection);
+          receiving = false;
+        }
+      }
+    });
+  } catch (error) {
+    await close();
+    throw error;
+  }
+}
+async function receive(fd, wait) {
+  const { ptr, symbols } = calls3();
+  const descriptors = [], body = Buffer.alloc(9);
+  let used = 0, delivered = false;
+  try {
+    for (;; ) {
+      const packet = message(body.subarray(used), Buffer.alloc(CONTROL_BYTES));
+      const count = Number(symbols.recvmsg(fd, ptr(packet.header), 128));
+      if (retry(count)) {
+        await wait();
+        continue;
+      }
+      checked2(count);
+      const controlBytes = packet.header.readUInt32LE(40);
+      let offset = 0;
+      while (offset + 12 <= controlBytes && controlBytes <= packet.control.length) {
+        const length = packet.control.readUInt32LE(offset);
+        if (length < 12 || length > controlBytes - offset || (length - 12) % 4 !== 0 || packet.control.readInt32LE(offset + 4) !== 65535 || packet.control.readInt32LE(offset + 8) !== 1)
+          throw new Error("invalid macOS descriptor control frame");
+        for (let index = offset + 12;index < offset + length; index += 4) {
+          const received = packet.control.readInt32LE(index);
+          if (received < 0)
+            throw new Error("invalid macOS received descriptor");
+          descriptors.push(received);
+          privateMacosFcntl(received, 2, 1);
+        }
+        offset += length;
+      }
+      if (offset !== controlBytes || (packet.header.readInt32LE(44) & ~128) !== 0 || descriptors.length > MAX_DESCRIPTORS)
+        throw new Error("truncated macOS descriptor frame");
+      used += count;
+      if (used > 8)
+        throw new Error("trailing macOS descriptor data");
+      if (count === 0)
+        break;
+    }
+    if (used !== 8 || !body.subarray(0, 4).equals(MAGIC) || descriptors.length === 0 || descriptors.length !== body.readUInt32LE(4))
+      throw new Error("invalid macOS descriptor frame");
+    for (const descriptor of descriptors) {
+      const info = fstatSync2(descriptor);
+      if (!info.isFile() && !info.isDirectory() || (privateMacosFcntl(descriptor, 3) & 3) !== 0)
+        throw new Error("macOS handoff requires read-only files or directories");
+    }
+    const ack = Buffer.from("A");
+    if (checked2(Number(symbols.send(fd, ptr(ack), 1, 524288))) !== 1)
+      throw new Error("macOS descriptor acknowledgement failed");
+    const record = { descriptors: Object.freeze([...descriptors]), closed: false };
+    const result = Object.freeze({
+      descriptors: record.descriptors,
+      close() {
+        if (record.closed)
+          return;
+        record.closed = true;
+        const errors = [];
+        for (const descriptor of descriptors.splice(0)) {
+          try {
+            closeSync3(descriptor);
+          } catch (error) {
+            errors.push(error);
+          }
+        }
+        if (errors.length)
+          throw new AggregateError(errors, "macOS transferred descriptor closure failed");
+      }
+    });
+    receivedBundles.set(result, record);
+    delivered = true;
+    return result;
+  } finally {
+    if (!delivered)
+      for (const descriptor of descriptors.splice(0))
+        closeSync3(descriptor);
+  }
+}
+async function sendPrivateMacosDescriptors(path, peer, descriptors, timeoutMs, signal) {
+  if (!Array.isArray(descriptors) || descriptors.length < 1 || descriptors.length > MAX_DESCRIPTORS || descriptors.some((fd2) => !Number.isSafeInteger(fd2) || fd2 < 0))
+    throw new Error("invalid macOS descriptor bundle");
+  const selected = [...descriptors], wait = budget(timeoutMs, signal), sockaddr = address(path);
+  const { symbols, ptr } = calls3(), fd = socket();
+  try {
+    signal?.throwIfAborted();
+    const connected = symbols.connect(fd, ptr(sockaddr), sockaddr[0]);
+    if (connected < 0) {
+      if (![4, 35, 36].includes(errno()))
+        checked2(connected);
+      const poll = Buffer.alloc(8);
+      poll.writeInt32LE(fd);
+      poll.writeInt16LE(4, 4);
+      while (checked2(symbols.poll(ptr(poll), 1, 0)) === 0)
+        await wait();
+      const error = Buffer.alloc(4), size = Buffer.alloc(4);
+      size.writeUInt32LE(4);
+      checked2(symbols.getsockopt(fd, 65535, 4103, ptr(error), ptr(size)));
+      if (error.readInt32LE() !== 0)
+        throw new Error("macOS descriptor connection failed");
+    }
+    authenticate(fd, peer);
+    const body = Buffer.alloc(8), control = Buffer.alloc(12 + selected.length * 4);
+    MAGIC.copy(body);
+    body.writeUInt32LE(selected.length, 4);
+    control.writeUInt32LE(control.length);
+    control.writeInt32LE(65535, 4);
+    control.writeInt32LE(1, 8);
+    selected.forEach((descriptor, index) => {
+      control.writeInt32LE(descriptor, 12 + index * 4);
+    });
+    const packet = message(body, control);
+    if (checked2(Number(symbols.sendmsg(fd, ptr(packet.header), 524416))) !== body.length)
+      throw new Error("macOS descriptor send was incomplete");
+    checked2(symbols.shutdown(fd, 1));
+    const ack = Buffer.alloc(2);
+    for (;; ) {
+      const count = Number(symbols.recv(fd, ptr(ack), ack.length, 128));
+      if (retry(count)) {
+        await wait();
+        continue;
+      }
+      if (checked2(count) !== 1 || ack[0] !== 65)
+        throw new Error("macOS descriptor receipt is unconfirmed");
+      return;
+    }
+  } finally {
+    closeSync3(fd);
+  }
+}
+
+// src/internal/macos-guardian-storage.ts
+import { constants as constants5 } from "fs";
+import { lstat, open as open4 } from "fs/promises";
+import { join as join5, posix as posix3 } from "path";
+
+// src/internal/macos-volume.ts
+import { execFile } from "child_process";
+import { createHmac as createHmac2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+import { constants as constants4 } from "fs";
+import { open as open3, realpath } from "fs/promises";
+import { dirname as dirname3, join as join4, posix as posix2 } from "path";
+var OPEN_DIRECTORY = constants4.O_RDONLY | constants4.O_DIRECTORY | 536870912 | 16777216;
+var HEX = /^[0-9a-f]{64}$/;
+var INTEGER = /^(0|[1-9][0-9]{0,19})$/;
+var MIB = 1024 * 1024;
+var IMAGE = "volume.dmg";
+var INTENT = "volume.json";
+var IMAGE_RECORD = "volume-image.json";
+var RETIRE_RECORD = "storage.release.json";
+function identity(stat) {
+  return { device: String(stat.dev), inode: String(stat.ino) };
+}
+function matches(stat, value) {
+  return String(stat.dev) === value.device && String(stat.ino) === value.inode;
+}
+function isIdentity(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const raw = value;
+  return typeof raw.device === "string" && INTEGER.test(raw.device) && typeof raw.inode === "string" && INTEGER.test(raw.inode) && raw.inode !== "0";
+}
+function capacity(bytes) {
+  if (!Number.isSafeInteger(bytes) || bytes < 16 * MIB || bytes > 512 * MIB || bytes % MIB !== 0)
+    throw new TypeError("macOS volume capacity is outside its finite profile");
+}
+function canonical(path) {
+  if (typeof path !== "string" || !path.startsWith("/") || posix2.normalize(path) !== path || path === "/" || Buffer.byteLength(path) > 900 || [...path].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) || Buffer.from(path).toString("utf8") !== path)
+    throw new TypeError("macOS volume requires a canonical private path");
+}
+async function privateDirectory2(path) {
+  privateMacosCurrentProcessIdentity();
+  canonical(path);
+  if (await realpath(path) !== path)
+    throw new Error("macOS volume directory is aliased");
+  const directory = await open3(path, OPEN_DIRECTORY);
+  try {
+    const stat = await directory.stat({ bigint: true });
+    if (!stat.isDirectory() || stat.uid !== BigInt(process.getuid()) || (stat.mode & 0o777n) !== 0o700n)
+      throw new Error("macOS volume directory is not private");
+    return directory;
+  } catch (error) {
+    await directory.close();
+    throw error;
+  }
+}
+async function sameDirectory(path, expected) {
+  const directory = await privateDirectory2(path);
+  try {
+    if (!matches(await directory.stat({ bigint: true }), expected))
+      throw new Error("macOS volume directory identity changed");
+  } finally {
+    await directory.close();
+  }
+}
+function signature2(token, name, value) {
+  if (!HEX.test(token))
+    throw new TypeError("invalid macOS volume ownership token");
+  return createHmac2("sha256", Buffer.from(token, "hex")).update(`jig-macos-volume\x00${name}\x00`).update(JSON.stringify(value)).digest();
+}
+async function writeRecord(parent, name, token, value, signatureName = name) {
+  const mac = signature2(token, signatureName, value).toString("hex");
+  const file = await privateMacosOpenAt(parent.fd, name, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL);
+  try {
+    await file.writeFile(`${JSON.stringify({ value, mac })}
+`);
+    await file.sync();
+    await parent.sync();
+  } finally {
+    await file.close();
+  }
+  return mac;
+}
+async function readRecord2(parent, name, token) {
+  const file = await privateMacosOpenAt(parent.fd, name, constants4.O_RDONLY | constants4.O_NONBLOCK);
+  try {
+    const before = await file.stat({ bigint: true });
+    if (!before.isFile() || before.uid !== BigInt(process.getuid()) || (before.mode & 0o777n) !== 0o600n || before.nlink !== 1n || before.size < 1n || before.size > 4096n)
+      throw new Error("macOS volume journal is unsafe");
+    const bytes = Buffer.alloc(Number(before.size) + 1);
+    let count = 0;
+    while (count < bytes.length) {
+      const read = await file.read(bytes, count, bytes.length - count, count);
+      if (!read.bytesRead)
+        break;
+      count += read.bytesRead;
+    }
+    const after = await file.stat({ bigint: true });
+    if (BigInt(count) !== before.size || before.size !== after.size || after.nlink !== 1n || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs)
+      throw new Error("macOS volume journal changed");
+    const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, count)));
+    if (parsed === null || typeof parsed !== "object" || Object.keys(parsed).sort().join() !== "mac,value" || typeof parsed.mac !== "string" || !HEX.test(parsed.mac) || !timingSafeEqual2(signature2(token, name, parsed.value), Buffer.from(parsed.mac, "hex")))
+      throw new Error("macOS volume ownership authentication failed");
+    return parsed;
+  } finally {
+    await file.close();
+  }
+}
+function systemTool(tool, args, input, signal) {
+  signal?.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const child = execFile(tool, args, {
+      cwd: "/",
+      env: { PATH: "/usr/bin:/bin", LC_ALL: "C" },
+      encoding: "buffer",
+      timeout: 30000,
+      killSignal: "SIGKILL",
+      maxBuffer: MIB,
+      signal
+    }, (error, stdout) => {
+      if (error)
+        reject(new Error(`macOS volume ${tool === "/usr/bin/hdiutil" ? args[0] ?? "operation" : "plist conversion"} failed`, { cause: error }));
+      else
+        resolve(stdout);
+    });
+    child.stdin?.on("error", () => {
+      return;
+    });
+    child.stdin?.end(input);
+  });
+}
+async function information(signal) {
+  const plist = await systemTool("/usr/bin/hdiutil", ["info", "-plist"], undefined, signal);
+  const json = await systemTool("/usr/bin/plutil", ["-convert", "json", "-o", "-", "-"], plist, signal);
+  const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(json));
+  if (!Array.isArray(parsed?.images) || parsed.images.length > 1024 || parsed.images.some((value) => value === null || typeof value !== "object"))
+    throw new Error("macOS image inventory is invalid");
+  return parsed.images;
+}
+async function attachedDeviceFromResult(plist, allocation, signal) {
+  const json = await systemTool("/usr/bin/plutil", ["-convert", "json", "-o", "-", "-"], plist, signal);
+  const parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(json));
+  const entities = parsed?.["system-entities"];
+  if (!Array.isArray(entities) || entities.length !== 1) {
+    throw new Error("macOS volume attachment result is invalid");
+  }
+  const entity = entities[0];
+  if (entity === null || typeof entity !== "object" || typeof entity["dev-entry"] !== "string" || !/^\/dev\/disk[1-9][0-9]{0,5}$/.test(entity["dev-entry"]) || entity["mount-point"] !== allocation.mount.path || entity["volume-kind"] !== "hfs")
+    throw new Error("macOS volume attachment does not match its allocation");
+  return entity["dev-entry"];
+}
+async function attached(controlPath, allocation, signal) {
+  const imagePath = join4(controlPath, IMAGE);
+  const images = await information(signal);
+  const candidates = images.filter((value) => value["image-path"] === imagePath);
+  if (candidates.length === 0)
+    return;
+  const item = candidates[0];
+  const entities = item["system-entities"];
+  if (candidates.length !== 1 || item["owner-uid"] !== process.getuid() || item.blocksize !== 512 || item.blockcount !== allocation.bytes / 512 || item["image-encrypted"] !== false || !Array.isArray(entities) || entities.length !== 1)
+    throw new Error("macOS image attachment does not match its allocation");
+  const entity = entities[0];
+  if (entity === null || typeof entity !== "object" || typeof entity["dev-entry"] !== "string" || !/^\/dev\/disk[1-9][0-9]{0,5}$/.test(entity["dev-entry"]) || entity["mount-point"] !== undefined && entity["mount-point"] !== allocation.mount.path)
+    throw new Error("macOS volume device does not match its allocation");
+  return entity["dev-entry"];
+}
+async function imageFile(parent, bytes, expected) {
+  const image = await privateMacosOpenAt(parent.fd, IMAGE, constants4.O_RDONLY | constants4.O_NONBLOCK);
+  try {
+    const stat = await image.stat({ bigint: true });
+    if (!stat.isFile() || stat.uid !== BigInt(process.getuid()) || stat.nlink !== 1n || stat.size > BigInt(bytes) || expected !== undefined && (!matches(stat, expected) || stat.size !== BigInt(bytes) || (stat.mode & 0o777n) !== 0o600n))
+      throw new Error("macOS volume backing identity changed");
+    return image;
+  } catch (error) {
+    await image.close();
+    throw error;
+  }
+}
+function validateAllocation(value) {
+  const raw = value;
+  if (raw === null || typeof raw !== "object" || Object.keys(raw).sort().join() !== "bytes,control,mount" || !isIdentity(raw.control) || Object.keys(raw.control).sort().join() !== "device,inode" || !isIdentity(raw.mount) || Object.keys(raw.mount).sort().join() !== "device,inode,path")
+    throw new Error("invalid macOS volume allocation");
+  canonical(raw.mount.path);
+  capacity(raw.bytes);
+  return raw;
+}
+async function attachPrivateMacosVolume(controlPath, token, signal) {
+  const parent = await privateDirectory2(controlPath);
+  let mounted;
+  try {
+    signal?.throwIfAborted();
+    const intent = await readRecord2(parent, INTENT, token);
+    const allocation = validateAllocation(intent.value);
+    const allocationMac = intent.mac;
+    const bytes = allocation.bytes, mountPath = allocation.mount.path;
+    if (!matches(await parent.stat({ bigint: true }), allocation.control))
+      throw new Error("macOS volume control directory changed");
+    for await (const entry of privateMacosDirectory(parent.fd))
+      if (entry.name.toString("utf8") !== INTENT)
+        throw new Error("macOS volume allocation has already been used");
+    await sameDirectory(mountPath, allocation.mount);
+    await sameDirectory(controlPath, allocation.control);
+    await systemTool("/usr/bin/hdiutil", [
+      "create",
+      "-sectors",
+      String(bytes / 512),
+      "-fs",
+      "Case-sensitive HFS+",
+      "-volname",
+      `Jig-${token.slice(0, 16)}`,
+      "-type",
+      "UDIF",
+      "-layout",
+      "NONE",
+      "-nospotlight",
+      join4(controlPath, IMAGE)
+    ], undefined, signal);
+    const image = await imageFile(parent, bytes);
+    let recordedImage;
+    try {
+      await image.chmod(384);
+      await image.sync();
+      const stat2 = await image.stat({ bigint: true });
+      if (stat2.size !== BigInt(bytes))
+        throw new Error("macOS volume capacity changed");
+      recordedImage = { ...identity(stat2), allocationMac };
+      await writeRecord(parent, IMAGE_RECORD, token, recordedImage);
+    } finally {
+      await image.close();
+    }
+    await sameDirectory(controlPath, allocation.control);
+    await sameDirectory(mountPath, allocation.mount);
+    const attachment = await systemTool("/usr/bin/hdiutil", [
+      "attach",
+      "-kernel",
+      "-nobrowse",
+      "-noautoopen",
+      "-noautofsck",
+      "-owners",
+      "on",
+      "-mountpoint",
+      mountPath,
+      "-mount",
+      "required",
+      "-plist",
+      join4(controlPath, IMAGE)
+    ], undefined, signal);
+    const device = await attachedDeviceFromResult(attachment, allocation, signal);
+    const checkedImage = await imageFile(parent, bytes, recordedImage);
+    await checkedImage.close();
+    await sameDirectory(controlPath, allocation.control);
+    mounted = await open3(mountPath, OPEN_DIRECTORY);
+    const filesystem = privateMacosFilesystem(mounted.fd);
+    const stat = await mounted.stat({ bigint: true });
+    if (filesystem.device !== device || filesystem.mountpoint !== mountPath || filesystem.type !== "hfs" || filesystem.capacityBytes < 1n || filesystem.capacityBytes > BigInt(bytes) || filesystem.owner !== process.getuid() || (filesystem.flags & 2097153) !== 0 || (filesystem.flags & 24) !== 24 || stat.dev === BigInt(allocation.mount.device))
+      throw new Error("macOS volume mount enforcement is unavailable");
+    await mounted.chmod(448);
+    await mounted.sync();
+    const result = Object.freeze({
+      path: mountPath,
+      directory: mounted,
+      capacityBytes: Number(filesystem.capacityBytes)
+    });
+    mounted = undefined;
+    return result;
+  } finally {
+    await mounted?.close();
+    await parent.close();
+  }
+}
+async function recoverPrivateMacosVolume(controlPath, token, signal) {
+  signal?.throwIfAborted();
+  const parent = await privateDirectory2(controlPath);
+  try {
+    let intent;
+    try {
+      intent = await readRecord2(parent, INTENT, token);
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+      const owner = await privateDirectory2(dirname3(controlPath));
+      try {
+        const retired = validateAllocation((await readRecord2(owner, RETIRE_RECORD, token)).value);
+        intent = { value: retired, mac: signature2(token, INTENT, retired).toString("hex") };
+      } finally {
+        await owner.close();
+      }
+    }
+    const allocation = validateAllocation(intent.value);
+    if (!matches(await parent.stat({ bigint: true }), allocation.control))
+      throw new Error("macOS volume control directory changed");
+    let recordedImage;
+    try {
+      const record = await readRecord2(parent, IMAGE_RECORD, token);
+      const value = record.value;
+      if (!isIdentity(value) || Object.keys(value).sort().join() !== "allocationMac,device,inode" || value.allocationMac !== intent.mac)
+        throw new Error("macOS volume backing journal is invalid");
+      recordedImage = value;
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+    }
+    let image;
+    try {
+      try {
+        image = await imageFile(parent, allocation.bytes, recordedImage);
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+      const device = await attached(controlPath, allocation, signal);
+      if (device !== undefined) {
+        if (recordedImage === undefined || image === undefined)
+          throw new Error("macOS attached image has no authenticated backing");
+        await sameDirectory(controlPath, allocation.control);
+        if (!matches(privateMacosStatAt(parent.fd, IMAGE), recordedImage))
+          throw new Error("macOS volume backing changed before detach");
+        await systemTool("/usr/bin/hdiutil", ["detach", device], undefined, signal);
+        await sameDirectory(allocation.mount.path, allocation.mount);
+      }
+      try {
+        await sameDirectory(allocation.mount.path, allocation.mount);
+        const mountParent = await open3(dirname3(allocation.mount.path), OPEN_DIRECTORY);
+        try {
+          const name = posix2.basename(allocation.mount.path);
+          if (!matches(privateMacosStatAt(mountParent.fd, name), allocation.mount))
+            throw new Error("macOS volume mount allocation changed");
+          privateMacosUnlinkAt(mountParent.fd, name, true);
+          await mountParent.sync();
+        } finally {
+          await mountParent.close();
+        }
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          throw error;
+      }
+      if (image !== undefined) {
+        const current = privateMacosStatAt(parent.fd, IMAGE);
+        if (!matches(current, identity(await image.stat({ bigint: true }))))
+          throw new Error("macOS volume backing changed before removal");
+        privateMacosUnlinkAt(parent.fd, IMAGE);
+        await parent.sync();
+      }
+    } finally {
+      await image?.close();
+    }
+  } finally {
+    await parent.close();
+  }
+}
+
+// src/internal/macos-guardian-storage.ts
+var DIRECTORY = constants5.O_RDONLY | constants5.O_DIRECTORY | 536870912 | 16777216;
+var controlPath = (owner) => join5(owner, "storage");
+function requirePrivateMacosGuardianStorage(storage, files, cwd) {
+  if (storage === null || typeof storage !== "object" || Object.keys(storage).sort().join() !== "bytes,collect,mountPath" || typeof storage.mountPath !== "string" || !storage.mountPath.startsWith("/") || storage.mountPath === "/" || posix3.normalize(storage.mountPath) !== storage.mountPath || !Number.isSafeInteger(storage.bytes) || storage.bytes < 16 * 1024 * 1024 || storage.bytes > 512 * 1024 * 1024 || storage.bytes % (1024 * 1024) !== 0 || ![null, "output", "work"].includes(storage.collect))
+    throw new TypeError("invalid macOS guardian storage");
+  const roots = ["work", "tmp", "output"].map((name) => join5(storage.mountPath, name));
+  if (files.writableTrees.some((path) => !roots.includes(path)) || !roots.some((root) => cwd === root || cwd.startsWith(`${root}/`)))
+    throw new TypeError("macOS writable projection is outside bounded storage");
+}
+async function preparePrivateMacosGuardianStorage(owner, token, storage, signal) {
+  const volume = await attachPrivateMacosVolume(controlPath(owner), token, signal);
+  try {
+    signal.throwIfAborted();
+    if (volume.path !== storage.mountPath || volume.capacityBytes > storage.bytes)
+      throw new Error("macOS guardian storage allocation changed");
+    for (const name of ["work", "tmp", "output", "inputs"])
+      privateMacosMkdirAt(volume.directory.fd, name, 448);
+    const collector = storage.collect === null ? undefined : await privateMacosOpenAt(volume.directory.fd, storage.collect, DIRECTORY);
+    return Object.freeze({ directory: volume.directory, collector });
+  } catch (error) {
+    await volume.directory.close();
+    throw error;
+  }
+}
+async function recoverPrivateMacosGuardianStorage(owner, token, signal) {
+  try {
+    await lstat(controlPath(owner));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  }
+  await recoverPrivateMacosVolume(controlPath(owner), token, signal);
+}
+
+// src/internal/macos-input-projection.ts
+import { constants as constants6, fstatSync as fstatSync3, readSync as readSync2 } from "fs";
+
+// src/internal/file-input-policy.ts
+import { createHash as createHash2 } from "crypto";
+var PRIVATE_FILE_LIMITS = Object.freeze({
+  bytes: 8 * 1024 * 1024,
+  files: 64,
+  entries: 256,
+  pathBytes: 512,
+  depth: 16,
+  captureMs: 1e4,
+  deliveryMs: 20000
+});
+var PRIVATE_CAPTURE_LIMITS = Object.freeze({
+  input: PRIVATE_FILE_LIMITS.bytes,
+  output: 16 * 1024 * 1024
+});
+var NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var protectedParts = new Set([".jig"]);
+var FILE_CONTROLS = /[\x00-\x1f\x7f]/;
+
+class PrivateFileInputError extends Error {
+  reason;
+  limit;
+  constructor(reason, limit) {
+    super({
+      filesystem: process.platform === "darwin" ? "use a local APFS or HFS+ filesystem" : "use a local ext4, XFS, Btrfs, or tmpfs filesystem",
+      native: process.platform === "darwin" ? "Jig could not load its native Mac file controls; check the supported-host requirements" : "Jig could not load its Linux file controls; check the supported glibc loader and libc installation",
+      mount: "the selected attachment mount could not be identified; select an available local directory",
+      symlink: "the selected attachment contains a symbolic link; select a directory and files without links",
+      missing: "the selected attachment directory or file does not exist; check --attach and --select",
+      access: "the selected attachment cannot be read by the current operator; check its file and directory permissions",
+      "cross-mount": "the selected attachment crosses a mount boundary; select each mounted directory separately",
+      kernel: "the kernel does not provide the required file controls; check the supported-host requirements",
+      path: "select a relative path without traversal or links, within 16 components and 512 UTF-8 bytes",
+      protected: "Jig state and host control files cannot be selected as input",
+      linked: "select only singly linked regular files",
+      "input-link": "the selected --input file cannot be a symbolic link",
+      regular: "select a regular input file, not a directory or special file",
+      changed: "selected input changed during capture; capture a stable source tree",
+      "input-changed": "the selected --input file changed during capture; retry with a stable file",
+      bytes: `selected file exceeds the remaining ${limit ?? 0}-byte input budget; select less data`,
+      files: "input exceeds 64 files; narrow the selection with --select",
+      entries: "input exceeds 256 tree entries; narrow the selection with --select",
+      deadline: "input capture exceeded its 10-second budget; select a smaller local tree"
+    }[reason]);
+    this.reason = reason;
+    this.limit = limit;
+  }
+}
+function privateFilePath(value) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value) > PRIVATE_FILE_LIMITS.pathBytes || Buffer.from(value).toString("utf8") !== value || value.includes("\\") || FILE_CONTROLS.test(value) || value.split("/").some((part) => !part || part === "." || part === ".." || protectedParts.has(process.platform === "darwin" ? part.toLowerCase() : part)) || value.split("/").length > PRIVATE_FILE_LIMITS.depth)
+    throw new PrivateFileInputError("path");
+  return value;
+}
+function privateAttachmentName(value) {
+  if (typeof value !== "string" || value.length > 64 || !NAME.test(value))
+    throw new TypeError("invalid attachment name");
+  return value;
+}
+function sha256(bytes) {
+  return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
+}
+
+// src/internal/macos-input-projection.ts
+var DIRECTORY2 = constants6.O_RDONLY | constants6.O_DIRECTORY | 536870912 | 16777216;
+function normalizePrivateMacosInputDirectories(value) {
+  if (!Array.isArray(value) || value.length > 8 || new Set(value).size !== value.length)
+    throw new TypeError("invalid macOS input directories");
+  return Object.freeze(value.map((name) => privateFilePath(privateAttachmentName(name))));
+}
+function normalizePrivateMacosInputs(value, inputDirectories) {
+  if (!Array.isArray(value) || value.length > PRIVATE_FILE_LIMITS.files)
+    throw new TypeError("invalid macOS input manifest");
+  const roots = new Set(normalizePrivateMacosInputDirectories(inputDirectories));
+  let bytes = 0;
+  const names = new Set, directories = new Set;
+  const files = value.map((file) => {
+    const entry = file;
+    if (entry === null || typeof entry !== "object" || Object.keys(entry).sort().join() !== "bytes,digest,path" || !Number.isSafeInteger(entry.bytes) || entry.bytes < 0 || typeof entry.digest !== "string" || !/^sha256:[0-9a-f]{64}$/.test(entry.digest))
+      throw new TypeError("invalid macOS input identity");
+    if (typeof entry.path !== "string")
+      throw new TypeError("invalid macOS input path");
+    const separator = entry.path.indexOf("/");
+    if (separator < 1 || !roots.has(entry.path.slice(0, separator)))
+      throw new TypeError("macOS input is outside its declared root");
+    privateFilePath(entry.path.slice(separator + 1));
+    const path = entry.path;
+    bytes += entry.bytes;
+    if (names.has(path) || bytes > PRIVATE_FILE_LIMITS.bytes)
+      throw new TypeError("macOS captured input exceeds its bounds");
+    names.add(path);
+    const parts = path.split("/");
+    for (let count = 2;count < parts.length; count++)
+      directories.add(parts.slice(0, count).join("/"));
+    return Object.freeze({ path, bytes: entry.bytes, digest: entry.digest });
+  });
+  if (names.size + directories.size > PRIVATE_FILE_LIMITS.entries || [...names].some((name) => directories.has(name)))
+    throw new TypeError("macOS input paths conflict or exceed their entry bound");
+  return Object.freeze(files);
+}
+async function projectPrivateMacosInputs(volume, manifest, inputDirectories, bundle, signal) {
+  const roots = normalizePrivateMacosInputDirectories(inputDirectories);
+  const files = normalizePrivateMacosInputs(manifest, roots);
+  const descriptors = bundle === undefined ? [] : requirePrivateMacosReceivedDescriptors(bundle);
+  if (files.length !== descriptors.length)
+    throw new Error("macOS input handoff count changed");
+  const root = await privateMacosOpenAt(volume.fd, "inputs", DIRECTORY2);
+  const directories = new Map([["", root]]);
+  const failures = [];
+  try {
+    for (const name of roots) {
+      signal.throwIfAborted();
+      privateMacosMkdirAt(root.fd, name, 448);
+      directories.set(name, await privateMacosOpenAt(root.fd, name, DIRECTORY2));
+    }
+    for (const [index, file] of files.entries()) {
+      signal.throwIfAborted();
+      const fd = descriptors[index];
+      const before = fstatSync3(fd, { bigint: true });
+      if (!before.isFile() || before.nlink !== 0n || before.size !== BigInt(file.bytes))
+        throw new Error("macOS transferred input is not the declared anonymous file");
+      const bytes = Buffer.alloc(file.bytes);
+      try {
+        for (let offset = 0;offset < bytes.length; ) {
+          const count = readSync2(fd, bytes, offset, bytes.length - offset, offset);
+          if (count === 0)
+            throw new Error("macOS transferred input ended early");
+          offset += count;
+        }
+        const after = fstatSync3(fd, { bigint: true });
+        if (sha256(bytes) !== file.digest || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || after.nlink !== 0n || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs)
+          throw new Error("macOS transferred input identity changed");
+        const parts = file.path.split("/");
+        let parent = root;
+        for (let count = 1;count < parts.length; count++) {
+          const key = parts.slice(0, count).join("/");
+          let directory = directories.get(key);
+          if (directory === undefined) {
+            privateMacosMkdirAt(parent.fd, parts[count - 1], 448);
+            directory = await privateMacosOpenAt(parent.fd, parts[count - 1], DIRECTORY2);
+            directories.set(key, directory);
+          }
+          parent = directory;
+        }
+        const output = await privateMacosOpenAt(parent.fd, parts.at(-1), constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL, 384);
+        try {
+          await output.writeFile(bytes);
+          await output.chmod(292);
+        } finally {
+          await output.close();
+        }
+      } finally {
+        bytes.fill(0);
+      }
+    }
+    for (const directory of [...directories.values()].reverse())
+      await directory.chmod(365);
+    signal.throwIfAborted();
+  } catch (error) {
+    failures.push(error);
+  }
+  const results = await Promise.allSettled([...directories.values()].map((directory) => directory.close()));
+  for (const result of results)
+    if (result.status === "rejected")
+      failures.push(result.reason);
+  if (failures.length)
+    throw new AggregateError(failures, "macOS input projection failed");
+}
+
+// src/internal/macos-output-policy.ts
+var PRIVATE_MACOS_MAX_OUTPUT_BYTES = 128 * 1024 * 1024;
+
+// src/internal/macos-scope-execution.ts
+import { spawn } from "child_process";
+
+// src/internal/macos-sandbox-profile.ts
+import { posix as posix4 } from "path";
+var SYSTEM_TREES = ["/usr/lib", "/System/Library", "/usr/share/icu"];
+var RESOLVER_FILES = [
+  "/etc",
+  "/var",
+  "/etc/resolv.conf",
+  "/private/etc/resolv.conf",
+  "/private/var/run/resolv.conf",
+  "/etc/hosts",
+  "/private/etc/hosts",
+  "/var/run/mDNSResponder",
+  "/private/var/run/mDNSResponder"
+];
+function path(value) {
+  if (typeof value !== "string" || !posix4.isAbsolute(value) || posix4.normalize(value) !== value || Buffer.byteLength(value) > 4096 || Buffer.from(value).toString("utf8") !== value || [...value].some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127))
+    throw new TypeError("invalid macOS sandbox path");
+  return value;
+}
+function inside(value, root) {
+  return root === "/" || value === root || value.startsWith(`${root}/`);
+}
+var intersects = (left, right) => inside(left, right) || inside(right, left);
+var literal = (value) => `(literal ${JSON.stringify(value)})`;
+var tree = (value) => `(subpath ${JSON.stringify(value)})`;
+function paths(values) {
+  if (!Array.isArray(values) || values.length > 128)
+    throw new TypeError("too many sandbox paths");
+  return [...new Set(values.map(path))].sort();
+}
+function privateMacosSandboxProfile(input) {
+  const readOnlyFiles = paths(input.readOnlyFiles);
+  const readOnlyTrees = paths(input.readOnlyTrees);
+  const writableTrees = paths(input.writableTrees);
+  const protectedRoots = paths(input.protectedRoots);
+  if (protectedRoots.length === 0 || !["isolated", "inherited"].includes(input.network))
+    throw new TypeError("macOS sandbox requires explicit control roots and network policy");
+  const grants = [...SYSTEM_TREES, ...readOnlyFiles, ...readOnlyTrees, ...writableTrees];
+  if (input.network === "inherited")
+    grants.push(...RESOLVER_FILES);
+  if (grants.some((grant) => protectedRoots.some((root) => intersects(grant, root))))
+    throw new TypeError("macOS payload grant overlaps host control");
+  if (writableTrees.some((write) => [...SYSTEM_TREES, ...readOnlyFiles, ...readOnlyTrees].some((read) => intersects(write, read))))
+    throw new TypeError("macOS writable grant overlaps immutable data");
+  const ancestors = new Set(["/"]);
+  for (const grant of grants) {
+    let parent = posix4.dirname(grant);
+    for (;; ) {
+      ancestors.add(parent);
+      if (parent === "/")
+        break;
+      parent = posix4.dirname(parent);
+    }
+  }
+  const fileParents = [...new Set(readOnlyFiles.map((file) => posix4.dirname(file)))].sort();
+  const rules = [
+    "(version 1)",
+    "(deny default)",
+    "(deny process-info* (require-not (target self)))",
+    "(allow process-fork process-exec)",
+    "(allow signal (target same-sandbox))",
+    '(allow sysctl-read (sysctl-name-regex #"^hw[.]") (sysctl-name "kern.osrelease") (sysctl-name "kern.osversion") (sysctl-name "kern.ostype"))',
+    '(allow file-read-data (literal "/"))',
+    `(allow file-read-metadata ${[...ancestors].sort().map(literal).join(" ")})`,
+    ...fileParents.length === 0 ? [] : [`(allow file-read-data ${fileParents.map(literal).join(" ")})`],
+    `(allow file-read* file-map-executable ${SYSTEM_TREES.map(tree).join(" ")} ${readOnlyFiles.map(literal).join(" ")} ${readOnlyTrees.map(tree).join(" ")})`,
+    ...writableTrees.length ? [`(allow file-read* file-write* file-map-executable ${writableTrees.map(tree).join(" ")})`] : [],
+    '(allow file-read-data file-write-data (literal "/dev/null") (literal "/dev/zero"))',
+    '(allow file-read-data (literal "/dev/random") (literal "/dev/urandom"))',
+    '(deny file-read* file-test-existence (with errno ENOENT) (subpath "/etc/codex") (subpath "/private/etc/codex"))'
+  ];
+  if (input.network === "inherited")
+    rules.push('(allow network-outbound (remote ip "*:*"))', `(allow file-read* ${RESOLVER_FILES.map(literal).join(" ")})`, '(allow network-outbound (literal "/var/run/mDNSResponder") (literal "/private/var/run/mDNSResponder"))', '(allow mach-lookup (global-name "com.apple.SystemConfiguration.DNSConfiguration"))');
+  const text = `${rules.join(`
+`)}
+`;
+  if (Buffer.byteLength(text) > 32768)
+    throw new TypeError("macOS sandbox profile exceeds its bound");
+  return Object.freeze({ text, bootstrap: input.network === "inherited" ? "dns" : "closed" });
+}
+
+// src/internal/macos-scope-execution.ts
+function requirePrivateMacosScopeLimits(value) {
+  const limits = Object.freeze({ ...value });
+  if (Object.keys(limits).sort().join() !== "cleanupTimeoutMs,cpuPeriodMicros,cpuQuotaMicros,deadlineUnixMs,memoryBytes,pids" || Object.values(limits).some((value2) => !Number.isSafeInteger(value2) || value2 <= 0) || limits.memoryBytes > 512 * 1024 * 1024 || limits.pids > 128 || limits.cpuQuotaMicros > limits.cpuPeriodMicros || limits.cpuPeriodMicros !== 1e5 || limits.cleanupTimeoutMs > 5000 || limits.deadlineUnixMs - Date.now() > 86400000)
+    throw new TypeError("invalid macOS scope limits");
+  return limits;
+}
+async function preparePrivateMacosScope(input) {
+  const owner = requirePrivateMacosCoalition(input.owner);
+  if (!owner.empty())
+    throw new Error("macOS scope is not initially empty");
+  const limits = requirePrivateMacosScopeLimits(input.limits);
+  const command = [...input.command];
+  const environment = { ...input.environment };
+  if (!input.launcher.startsWith("/") || !input.cwd.startsWith("/") || !command[0]?.startsWith("/") || command.length > 64 || command.some((value) => typeof value !== "string" || value.includes("\x00")) || Buffer.byteLength(command.join("\x00")) > 16384 || Object.entries(environment).some(([name, value]) => !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || /^(?:_?DYLD_|LD_)/.test(name) || typeof value !== "string" || value.includes("\x00")) || Buffer.byteLength(JSON.stringify(environment)) > 16384)
+    throw new TypeError("invalid macOS native launch");
+  const profile = privateMacosSandboxProfile(input.files);
+  if (![...input.files.readOnlyTrees, ...input.files.writableTrees].some((root) => input.cwd === root || input.cwd.startsWith(`${root}/`)))
+    throw new TypeError("macOS working directory is outside its directory projections");
+  const hardDeadline = performance.now() + Math.max(0, limits.deadlineUnixMs - Date.now());
+  const initial = owner.sample();
+  if (!initial.complete || initial.active !== 1n)
+    throw new Error("macOS initial accounting is incomplete");
+  let previousCpu = initial.cpuNanoseconds;
+  let previousTime = performance.now();
+  let credit = BigInt(limits.cpuQuotaMicros) * 1000n;
+  const burst = credit;
+  const debtLimit = 2500000000n * BigInt(limits.cpuQuotaMicros) / BigInt(limits.cpuPeriodMicros);
+  let paused = false, admitted = false, rootExited = false;
+  let reason;
+  let incompleteSince;
+  let peakFootprint = 0n, peakTasks = 0, samples = 0, pauses = 0, incompleteSamples = 0, maxSample = 0;
+  let terminal;
+  let readyFrame;
+  let frameBytes = Buffer.alloc(0);
+  const stop = (why) => {
+    if (reason === undefined || reason === "payload_exit")
+      reason = why;
+  };
+  const child = spawn(input.launcher, ["--launch", String(Buffer.byteLength(profile.text)), input.cwd, profile.bootstrap, ...command], { cwd: "/", env: environment, stdio: ["pipe", "pipe", "pipe", "pipe", "pipe", "pipe"] });
+  child.on("error", () => stop("setup_failed"));
+  const { stdin, stdout, stderr } = child;
+  const configuration = child.stdio[3];
+  const gate = child.stdio[4];
+  const frames = child.stdio[5];
+  if (stdin === null || stdout === null || stderr === null || !configuration || !gate || !frames) {
+    const cleanupBy = performance.now() + limits.cleanupTimeoutMs;
+    while (!owner.empty()) {
+      owner.signalMembers("kill");
+      if (performance.now() >= cleanupBy)
+        throw new Error("macOS descendant fencing is unconfirmed");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    throw new Error("macOS launch handoffs are unavailable");
+  }
+  let resolveReady = () => {};
+  const ready = new Promise((resolve) => {
+    resolveReady = resolve;
+  });
+  ready.catch(() => {
+    return;
+  });
+  const receiveFrame = (bytes) => {
+    if (frameBytes.length + bytes.length > 32)
+      return stop("setup_failed");
+    frameBytes = Buffer.concat([frameBytes, bytes]);
+    if (frameBytes.length >= 16 && readyFrame === undefined) {
+      const pid = frameBytes.readUInt32LE(4), version = frameBytes.readUInt32LE(8);
+      if (frameBytes.readUInt32LE(0) !== 1246316365 || frameBytes.readUInt32LE(12) !== 0 || !owner.contains(pid, version))
+        return stop("setup_failed");
+      readyFrame = { pid, version };
+      resolveReady(readyFrame);
+    }
+    if (frameBytes.length === 32) {
+      const code = frameBytes.readUInt32LE(24), signal = frameBytes.readUInt32LE(28);
+      if (frameBytes.readUInt32LE(16) !== 1246316376 || frameBytes.readUInt32LE(20) !== readyFrame?.pid || !(code <= 255 && signal === 0 || code === 4294967295 && signal > 0 && signal < 32))
+        return stop("setup_failed");
+      terminal = { exitCode: code === 4294967295 ? null : code, signal: signal || null };
+    }
+  };
+  frames.on("data", (bytes) => {
+    try {
+      receiveFrame(bytes);
+    } catch {
+      stop("setup_failed");
+    }
+  });
+  stdin.on("error", (error) => {
+    if (!admitted || error.code !== "EPIPE")
+      stop("setup_failed");
+  });
+  for (const stream of [stdout, stderr, configuration, gate, frames])
+    stream.on("error", () => stop("setup_failed"));
+  const frameEnd = new Promise((resolve) => frames.once("end", resolve));
+  const exit = new Promise((resolve) => {
+    child.once("error", () => {
+      stop("setup_failed");
+      rootExited = true;
+      resolve();
+    });
+    child.once("exit", (code) => {
+      if (code !== 0 && reason === undefined)
+        stop("setup_failed");
+      rootExited = true;
+      resolve();
+    });
+  });
+  configuration.end(profile.text);
+  const startupTimeout = setTimeout(() => stop("setup_failed"), 9000);
+  const completion = (async () => {
+    try {
+      while (reason === undefined && !rootExited) {
+        const now = performance.now();
+        if (now >= hardDeadline) {
+          stop("deadline");
+          break;
+        }
+        const sample = owner.sample();
+        samples++;
+        maxSample = Math.max(maxSample, sample.sampleMilliseconds);
+        if (sample.footprintBytes > peakFootprint)
+          peakFootprint = sample.footprintBytes;
+        peakTasks = Math.max(peakTasks, Number(sample.active - 1n));
+        if (sample.footprintBytes > BigInt(limits.memoryBytes)) {
+          stop("memory_limit");
+          break;
+        }
+        if (sample.active - 1n > BigInt(limits.pids)) {
+          stop("process_limit");
+          break;
+        }
+        if (!sample.complete) {
+          incompleteSamples++;
+          incompleteSince ??= now;
+        } else
+          incompleteSince = undefined;
+        if (incompleteSince !== undefined && now - incompleteSince > 500) {
+          stop("accounting_failed");
+          break;
+        }
+        if (sample.cpuNanoseconds < previousCpu) {
+          stop("accounting_failed");
+          break;
+        }
+        credit += BigInt(Math.max(0, Math.floor((now - previousTime) * 1e6))) * BigInt(limits.cpuQuotaMicros) / BigInt(limits.cpuPeriodMicros) - (sample.cpuNanoseconds - previousCpu);
+        if (credit > burst)
+          credit = burst;
+        previousCpu = sample.cpuNanoseconds;
+        previousTime = now;
+        if (credit < -debtLimit) {
+          stop("cpu_limit");
+          break;
+        }
+        if (credit < 0) {
+          owner.signalMembers("stop");
+          if (!paused)
+            pauses++;
+          paused = true;
+        } else if (paused) {
+          owner.signalMembers("continue");
+          paused = false;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+    } catch {
+      stop("accounting_failed");
+    } finally {
+      clearTimeout(startupTimeout);
+    }
+    reason ??= "payload_exit";
+    const cleanupBy = performance.now() + limits.cleanupTimeoutMs;
+    while (!owner.empty()) {
+      owner.signalMembers("kill");
+      if (performance.now() >= cleanupBy)
+        throw new Error("macOS descendant fencing is unconfirmed");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    await bounded(exit, Math.max(1, cleanupBy - performance.now()));
+    await bounded(frameEnd, Math.max(1, cleanupBy - performance.now())).catch(() => {
+      return;
+    });
+    if (reason === "payload_exit" && terminal === undefined)
+      reason = "setup_failed";
+    const final = owner.sample();
+    if (!final.complete || final.active !== 1n || final.cpuNanoseconds < previousCpu)
+      throw new Error("macOS final resource accounting is unconfirmed");
+    return Object.freeze({
+      reason,
+      exitCode: terminal?.exitCode ?? null,
+      signal: terminal?.signal ?? null,
+      fenced: true,
+      evidence: Object.freeze({
+        cpuNanoseconds: (final.cpuNanoseconds - initial.cpuNanoseconds).toString(),
+        peakFootprintBytes: peakFootprint.toString(),
+        peakTasks,
+        samples,
+        pauses,
+        incompleteSamples,
+        maxSampleMilliseconds: maxSample
+      })
+    });
+  })();
+  completion.catch(() => {
+    return;
+  });
+  try {
+    const identity2 = await Promise.race([
+      ready,
+      completion.then((result) => {
+        throw new Error(`macOS scope ended before readiness (${result.reason}, exit ${result.exitCode ?? "null"}, signal ${result.signal ?? "null"})`);
+      })
+    ]);
+    return Object.freeze({
+      stdin,
+      stdout,
+      stderr,
+      ...identity2,
+      completion,
+      admit() {
+        if (performance.now() >= hardDeadline)
+          stop("deadline");
+        if (admitted || reason !== undefined || !owner.contains(identity2.pid, identity2.version))
+          throw new Error("macOS scope is no longer admissible");
+        admitted = true;
+        clearTimeout(startupTimeout);
+        gate.end("A");
+      },
+      stop: (why) => stop(why)
+    });
+  } catch (error) {
+    stop("setup_failed");
+    await completion;
+    throw error;
+  }
+}
+async function bounded(promise, milliseconds) {
+  let timer;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error("macOS native settlement expired")), milliseconds);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/internal/macos-native-supervisor.ts
+var POLICY = ["--no-env-file", "--no-install", "--config=/dev/null"];
+function object(value, keys) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || Object.keys(value).sort().join() !== keys.split(",").sort().join())
+    throw new Error("invalid macOS guardian message");
+  return value;
+}
+function startMessage(value) {
+  if (value?.type === "recover-storage") {
+    const record2 = object(value, "type,ownerDirectory,ownerToken,targetDirectory,targetToken,deadlineUnixMs");
+    if (typeof record2.ownerDirectory !== "string" || typeof record2.ownerToken !== "string" || typeof record2.targetDirectory !== "string" || typeof record2.targetToken !== "string" || record2.ownerDirectory !== join6(record2.targetDirectory, "recovery") || record2.ownerToken !== privateMacosStorageRecoveryToken(record2.targetToken) || !Number.isSafeInteger(record2.deadlineUnixMs) || record2.deadlineUnixMs <= Date.now() || record2.deadlineUnixMs > Date.now() + 30000)
+      throw new Error("invalid macOS storage recovery configuration");
+    requirePrivateMacosOwnerDirectory(record2.targetDirectory);
+    return record2;
+  }
+  const record = object(value, `type,ownerDirectory,ownerToken,launcher,cwd,command,environment,files,limits,maxOutputBytes${[
+    "storage",
+    "inputs",
+    "inputDirectories"
+  ].filter((key) => value !== null && typeof value === "object" && Object.hasOwn(value, key)).map((key) => `,${key}`).join("")}`);
+  if (record.type !== "start" || typeof record.ownerDirectory !== "string" || !record.ownerDirectory.startsWith("/") || typeof record.ownerToken !== "string" || !/^[a-f0-9]{64}$/.test(record.ownerToken) || typeof record.launcher !== "string" || typeof record.cwd !== "string" || !Array.isArray(record.command) || record.environment === null || typeof record.environment !== "object" || Array.isArray(record.environment) || !Number.isSafeInteger(record.maxOutputBytes) || record.maxOutputBytes < 1 || record.maxOutputBytes > PRIVATE_MACOS_MAX_OUTPUT_BYTES)
+    throw new Error("invalid macOS guardian configuration");
+  object(record.files, "readOnlyFiles,readOnlyTrees,writableTrees,protectedRoots,network");
+  object(record.limits, "memoryBytes,pids,cpuQuotaMicros,cpuPeriodMicros,deadlineUnixMs,cleanupTimeoutMs");
+  requirePrivateMacosScopeLimits(record.limits);
+  if (record.storage !== undefined)
+    requirePrivateMacosGuardianStorage(record.storage, record.files, record.cwd);
+  if (record.inputs !== undefined || record.inputDirectories !== undefined) {
+    const roots = normalizePrivateMacosInputDirectories(record.inputDirectories);
+    normalizePrivateMacosInputs(record.inputs, roots);
+    if (record.storage === undefined || !record.files.readOnlyTrees.includes(join6(record.storage.mountPath, "inputs")))
+      throw new Error("macOS inputs require an immutable bounded projection");
+  }
+  return record;
+}
+async function connected(path2, pid, version) {
+  const socket2 = connect(path2);
+  socket2.on("error", () => {
+    return;
+  });
+  try {
+    await privateMacosBefore(new Promise((resolve, reject) => {
+      socket2.once("connect", resolve);
+      socket2.once("error", reject);
+    }), 1e4);
+    const peer = privateMacosPeerIdentity(socket2);
+    if (peer.uid !== process.getuid?.() || peer.realUid !== peer.uid || peer.pid !== pid || peer.version !== version)
+      throw new Error("macOS coordinator identity does not match");
+    return socket2;
+  } catch (error) {
+    socket2.destroy();
+    throw error;
+  }
+}
+async function supervise(path2, coordinatorPid, coordinatorVersion) {
+  const owner = acquirePrivateMacosCoalition();
+  const control = await connected(path2, coordinatorPid, coordinatorVersion);
+  const channel = privateMacosControlChannel(control);
+  const streams = [];
+  let execution;
+  let collector;
+  let storageRoot;
+  let inputReceiver;
+  let inputBundle;
+  let configuration;
+  const cancellation = new AbortController;
+  let releaseCollection = () => {};
+  const collection = new Promise((resolve) => {
+    releaseCollection = resolve;
+  });
+  let stopped;
+  let resolveAdmission = () => {};
+  let rejectAdmission = () => {};
+  const admission = new Promise((resolve, reject) => {
+    resolveAdmission = resolve;
+    rejectAdmission = reject;
+  });
+  admission.catch(() => {
+    return;
+  });
+  let phase = "starting";
+  const currentPhase = () => phase;
+  const stop = (reason) => {
+    stopped ??= reason;
+    cancellation.abort();
+    releaseCollection();
+    rejectAdmission(new Error("macOS guardian admission stopped"));
+    execution?.stop(reason);
+  };
+  control.on("close", () => {
+    if (phase !== "terminal")
+      stop("coordinator_lost");
+  });
+  let timer;
+  try {
+    configuration = startMessage(await privateMacosBefore(channel.receive(), 1e4));
+    if (stopped !== undefined)
+      throw new Error("macOS guardian coordinator lost during setup");
+    recordPrivateMacosOwner(configuration.ownerDirectory, configuration.ownerToken, owner);
+    if (configuration.type === "start" && (configuration.inputs?.length ?? 0) > 0)
+      inputReceiver = await createPrivateMacosDescriptorReceiver(dirname4(path2), "inputs");
+    for (const suffix of [".in", ".out", ".err"]) {
+      const stream = await connected(`${path2}${suffix}`, coordinatorPid, coordinatorVersion);
+      stream.on("error", () => stop("coordinator_lost"));
+      streams.push(stream);
+    }
+    const [stdin, stdout, stderr] = streams;
+    phase = "prepared";
+    channel.send({ type: "prepared", identity: owner.identity });
+    const operationDeadline = configuration.type === "start" ? configuration.limits.deadlineUnixMs : configuration.deadlineUnixMs;
+    timer = setTimeout(() => stop("cancelled"), Math.max(0, Math.min(1e4, operationDeadline - Date.now())));
+    const commands = (async () => {
+      for (;; ) {
+        const next = object(await channel.receive(), "type");
+        if (next.type === "cancel")
+          stop("cancelled");
+        else if (next.type === "release" && currentPhase() === "collecting")
+          releaseCollection();
+        else if (next.type === "admit" && phase === "prepared" && stopped === undefined) {
+          clearTimeout(timer);
+          timer = setTimeout(() => stop("cancelled"), Math.max(0, operationDeadline - Date.now()));
+          phase = "preparing";
+          resolveAdmission();
+        } else if (next.type === "continue" && currentPhase() === "ready" && stopped === undefined) {
+          execution?.admit();
+          phase = "running";
+        } else
+          throw new Error("invalid macOS guardian transition");
+      }
+    })();
+    commands.catch(() => stop("coordinator_lost"));
+    await admission;
+    if (stopped !== undefined)
+      throw new Error("macOS guardian stopped before preparation");
+    if (configuration.type === "recover-storage") {
+      await recoverPrivateMacosGuardianStorage(configuration.targetDirectory, configuration.targetToken, cancellation.signal);
+      const fencedBy = performance.now() + 5000;
+      while (!owner.empty()) {
+        owner.signalMembers("kill");
+        if (performance.now() >= fencedBy)
+          throw new Error("macOS recovery tools are not fenced");
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+      cancellation.signal.throwIfAborted();
+      phase = "terminal";
+      stdin.destroy();
+      stdout.end();
+      stderr.end();
+      channel.send({ type: "terminal", result: null, outputLost: false });
+      await privateMacosBefore(new Promise((resolve) => control.end(resolve)), 1000);
+      return;
+    }
+    if (inputReceiver !== undefined) {
+      inputBundle = await inputReceiver.receive({ pid: coordinatorPid, version: coordinatorVersion }, 5000, cancellation.signal);
+      await inputReceiver.close();
+    }
+    if (configuration.storage !== undefined) {
+      const storage = await preparePrivateMacosGuardianStorage(configuration.ownerDirectory, configuration.ownerToken, configuration.storage, cancellation.signal);
+      collector = storage.collector;
+      storageRoot = storage.directory;
+    }
+    if ((configuration.inputDirectories?.length ?? 0) > 0) {
+      await projectPrivateMacosInputs(storageRoot, configuration.inputs, configuration.inputDirectories, inputBundle, cancellation.signal);
+      inputBundle?.close();
+      inputBundle = undefined;
+    }
+    await storageRoot?.close();
+    storageRoot = undefined;
+    cancellation.signal.throwIfAborted();
+    execution = await preparePrivateMacosScope({
+      ...configuration,
+      owner,
+      files: {
+        ...configuration.files,
+        protectedRoots: [
+          ...configuration.files.protectedRoots,
+          configuration.ownerDirectory,
+          dirname4(path2)
+        ]
+      }
+    });
+    clearTimeout(timer);
+    if (stopped !== undefined)
+      execution.stop(stopped);
+    let outputBytes = 0;
+    let outputLost = false;
+    const maxOutputBytes = configuration.maxOutputBytes;
+    for (const [source, destination] of [
+      [execution.stdout, stdout],
+      [execution.stderr, stderr]
+    ]) {
+      const bounded2 = new Transform({
+        transform(bytes, _encoding, callback) {
+          if (outputBytes + bytes.length > maxOutputBytes) {
+            callback(new Error("macOS payload output exceeded its limit"));
+            return;
+          }
+          outputBytes += bytes.length;
+          callback(null, bytes);
+        }
+      });
+      bounded2.on("error", () => {
+        outputLost = true;
+        stop("cancelled");
+        source.unpipe(bounded2);
+        source.pause();
+        destination.end();
+      });
+      source.pipe(bounded2).pipe(destination);
+      destination.on("close", () => {
+        if (!destination.writableFinished && phase !== "terminal") {
+          outputLost = true;
+          stop("coordinator_lost");
+        }
+      });
+    }
+    stdin.pipe(execution.stdin);
+    phase = "ready";
+    channel.send({ type: "ready", pid: execution.pid, version: execution.version });
+    const result = await execution.completion;
+    stdin.destroy();
+    for (const destination of [stdout, stderr]) {
+      if (!destination.writableFinished) {
+        try {
+          await privateMacosBefore(new Promise((resolve, reject) => {
+            destination.once("finish", resolve);
+            destination.once("error", reject);
+            destination.once("close", () => reject(new Error("macOS output closed before delivery")));
+          }), 1000);
+        } catch {
+          outputLost = true;
+          destination.destroy();
+        }
+      }
+    }
+    execution.stdout.destroy();
+    execution.stderr.destroy();
+    if (configuration.storage !== undefined) {
+      phase = "collecting";
+      const collect = collector !== undefined && stopped === undefined && !outputLost && result.reason === "payload_exit" && result.exitCode === 0;
+      channel.send({ type: "fenced", result, outputLost, collect });
+      if (collect) {
+        await sendPrivateMacosDescriptors(join6(dirname4(path2), "fd-output"), { pid: coordinatorPid, version: coordinatorVersion }, [collector.fd], 5000, cancellation.signal);
+        await privateMacosBefore(collection, 21000);
+      }
+      await collector?.close();
+      collector = undefined;
+      await recoverPrivateMacosGuardianStorage(configuration.ownerDirectory, configuration.ownerToken, AbortSignal.timeout(30000));
+      if (stopped !== undefined)
+        outputLost = true;
+    }
+    phase = "terminal";
+    channel.send({ type: "terminal", result, outputLost });
+    await privateMacosBefore(new Promise((resolve) => control.end(resolve)), 1000);
+  } catch (error) {
+    cancellation.abort();
+    execution?.stop("coordinator_lost");
+    let result;
+    if (execution !== undefined)
+      result = await execution.completion;
+    const cleanupBy = performance.now() + (configuration?.type === "start" ? configuration.limits.cleanupTimeoutMs : 5000);
+    while (!owner.empty()) {
+      owner.signalMembers("kill");
+      if (performance.now() >= cleanupBy)
+        throw new Error("macOS guardian cleanup is unconfirmed");
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+    if (!owner.empty())
+      throw new Error("macOS guardian cleanup is unconfirmed");
+    await storageRoot?.close();
+    storageRoot = undefined;
+    await collector?.close();
+    collector = undefined;
+    if (configuration?.type === "start" && configuration.storage !== undefined)
+      await recoverPrivateMacosGuardianStorage(configuration.ownerDirectory, configuration.ownerToken, AbortSignal.timeout(30000));
+    phase = "terminal";
+    try {
+      channel.send({ type: "terminal", result: result ?? null, outputLost: true });
+      await privateMacosBefore(new Promise((resolve) => control.end(resolve)), 1000);
+    } catch {}
+    if (stopped === undefined)
+      throw error;
+  } finally {
+    clearTimeout(timer);
+    inputBundle?.close();
+    await inputReceiver?.close();
+    await storageRoot?.close();
+    await collector?.close();
+    for (const socket2 of streams)
+      socket2.destroy();
+    channel.close();
+  }
+}
+if (import.meta.main) {
+  (async () => {
+    const [mode, path2, pid, version, extra] = process.argv.slice(2);
+    if (mode !== "--guardian" || path2 === undefined || !path2.startsWith("/") || Buffer.byteLength(path2) > 98 || !/^[1-9][0-9]*$/.test(pid ?? "") || !/^[0-9]+$/.test(version ?? "") || extra !== undefined || process.cwd() !== "/" || Object.keys(process.env).length !== 0 || process.execArgv.join("\x00") !== POLICY.join("\x00"))
+      throw new Error("invalid macOS guardian startup posture");
+    await supervise(path2, Number(pid), Number(version));
+  })().catch(() => {
+    process.exitCode = 70;
+  });
+}