@warlock.js/process 0.0.0-stage → 5.34.0

package/cjs/index.cjs

@@ -0,0 +1,1023 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_child_process = require("node:child_process");
+let node_crypto = require("node:crypto");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_stream = require("node:stream");
+let node_timers_promises = require("node:timers/promises");
+let node_fs_promises = require("node:fs/promises");
+let node_util = require("node:util");
+let node_net = require("node:net");
+
+//#region ../../packages/process/src/resources.ts
+function mountedCgroup(membership) {
+	const mount = "/sys/fs/cgroup";
+	const directory = node_path.default.resolve(mount, `.${membership}`);
+	return directory === mount || directory.startsWith(`${mount}/`) ? directory : void 0;
+}
+function validateLimits(limits, platform = process.platform) {
+	for (const [key, value] of Object.entries(limits)) if (![
+		"timeoutMs",
+		"memoryBytes",
+		"cpuSeconds",
+		"virtualMemoryBytes"
+	].includes(key) || !Number.isSafeInteger(value) || value <= 0) throw new Error(`Invalid process limit: ${key}`);
+	if (platform !== "linux" && limits.virtualMemoryBytes !== void 0) throw new Error("virtualMemoryBytes is supported only on Linux");
+	if (platform === "win32" && limits.cpuSeconds !== void 0) throw new Error("cpuSeconds is supported only on POSIX platforms");
+}
+/**
+* POSIX shell applies inherited limits. Linux stops here; macOS execs a gated guardian.
+* Flags/units: Apple's bash-3.2/builtins/ulimit.def and installed Bash manual.
+* https://github.com/apple-oss-distributions/bash/blob/main/bash-3.2/builtins/ulimit.def
+*/
+function launcher(limits, platform = process.platform) {
+	const commands = ["set -e"];
+	if (limits.cpuSeconds) commands.push(`ulimit -t ${limits.cpuSeconds}`);
+	if (limits.virtualMemoryBytes) commands.push(`ulimit -v ${Math.ceil(limits.virtualMemoryBytes / 1024)}`);
+	if (limits.memoryBytes) commands.push(`ulimit -${platform === "darwin" ? "d" : "m"} ${Math.ceil(limits.memoryBytes / 1024)}`);
+	if (platform === "linux") commands.push("kill -STOP \"$$\"");
+	commands.push("exec \"$@\"");
+	return commands.join("\n");
+}
+/** https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html */
+async function attachCgroup(pid, token, limits, root) {
+	if (process.platform !== "linux") return void 0;
+	let directory;
+	try {
+		const own = (await (0, node_fs_promises.readFile)("/proc/self/cgroup", "utf8")).split("\n").find((line) => line.startsWith("0::"))?.slice(3);
+		if (!root && own === void 0) return void 0;
+		const parent = root ?? mountedCgroup(own ?? "/");
+		if (!parent) return void 0;
+		await (0, node_fs_promises.readFile)(node_path.default.join(parent, "cgroup.controllers"), "utf8");
+		directory = node_path.default.join(parent, `warlock-${token}`);
+		await (0, node_fs_promises.mkdir)(directory);
+		if (limits.memoryBytes) {
+			await (0, node_fs_promises.writeFile)(node_path.default.join(directory, "memory.max"), String(limits.memoryBytes));
+			await (0, node_fs_promises.writeFile)(node_path.default.join(directory, "memory.oom.group"), "1");
+		}
+		await (0, node_fs_promises.writeFile)(node_path.default.join(directory, "cgroup.procs"), String(pid));
+		return directory;
+	} catch {
+		if (directory) await (0, node_fs_promises.rmdir)(directory).catch(() => void 0);
+		return;
+	}
+}
+async function cgroupMemory(directory) {
+	const [peak, events] = await Promise.all([(0, node_fs_promises.readFile)(node_path.default.join(directory, "memory.peak"), "utf8").catch(() => "0"), (0, node_fs_promises.readFile)(node_path.default.join(directory, "memory.events"), "utf8").catch(() => "")]);
+	return {
+		peak: Number(peak) || 0,
+		oom: Number(/^oom_kill (\d+)/m.exec(events)?.[1] ?? 0) > 0
+	};
+}
+/** Only reattach the token-specific cgroup confirmed by the kernel membership file. */
+async function recoveredCgroup(pid, token) {
+	if (process.platform !== "linux") return void 0;
+	let source;
+	try {
+		source = await (0, node_fs_promises.readFile)(`/proc/${pid}/cgroup`, "utf8");
+	} catch (error) {
+		if (["ENOENT", "ESRCH"].includes(String(error.code))) return void 0;
+		throw error;
+	}
+	const membership = source.split("\n").find((line) => line.startsWith("0::"))?.slice(3);
+	if (!membership || node_path.default.basename(membership) !== `warlock-${token}`) return void 0;
+	return mountedCgroup(membership);
+}
+async function cleanCgroup(directory) {
+	await (0, node_fs_promises.writeFile)(node_path.default.join(directory, "cgroup.kill"), "1").catch(() => void 0);
+	await (0, node_fs_promises.rmdir)(directory).catch(() => void 0);
+}
+
+//#endregion
+//#region ../../packages/process/src/guardian.ts
+function guardianAddress(platform, pid, uid) {
+	return platform === "win32" ? `\\\\.\\pipe\\warlock-process-${pid}` : `/tmp/warlock-process-${uid}-${pid}.sock`;
+}
+/** A live guardian reads its own environment, never argv, to prove ownership.
+* Node IPC is native-free: https://nodejs.org/api/net.html#ipc-support
+* The stable root PID stays alive for the workload and survives supervisor restarts.
+*/
+const guardianScript = String.raw`
+const { createServer } = require("node:net");
+const { createHmac } = require("node:crypto");
+const { spawn } = require("node:child_process");
+const { chmodSync, unlinkSync } = require("node:fs");
+const token = process.env.WARLOCK_PROCESS_TOKEN;
+const address = process.platform === "win32"
+  ? "\\\\.\\pipe\\warlock-process-" + process.pid
+  : "/tmp/warlock-process-" + process.getuid() + "-" + process.pid + ".sock";
+let gated = true;
+const finish = (code) => { server.close(); process.exit(code); };
+const start = () => {
+  if (!gated) return;
+  gated = false;
+  const [command, ...args] = JSON.parse(process.env.WARLOCK_PROCESS_LAUNCH);
+  const env = { ...process.env };
+  for (const key of Object.keys(env)) {
+    const name = process.platform === "win32" ? key.toUpperCase() : key;
+    if (name === "WARLOCK_PROCESS_TOKEN" || name === "WARLOCK_PROCESS_LAUNCH") delete env[key];
+  }
+  const child = spawn(command, args, { env, stdio: "inherit", windowsHide: true });
+  child.on("error", (error) => { console.error(error.message); finish(127); });
+  child.on("exit", (code, signal) => {
+    if (signal && process.platform !== "win32") process.kill(process.pid, signal);
+    else finish(code ?? 1);
+  });
+};
+const server = createServer((socket) => {
+  socket.setTimeout(2000, () => socket.destroy());
+  socket.on("error", () => {});
+  let input = "";
+  socket.on("data", (chunk) => {
+    input += chunk;
+    if (input.length > 1024) { socket.destroy(); return; }
+    if (!input.endsWith("\n")) return;
+    try {
+      const request = JSON.parse(input);
+      if (!/^[a-f0-9]{64}$/.test(request.nonce)) { socket.destroy(); return; }
+      const sign = (value) => createHmac("sha256", token).update(value).digest("hex");
+      if (request.resume === sign(request.nonce + ":resume")) start();
+      socket.end(JSON.stringify({ pid: process.pid, digest: sign(request.nonce + ":" + process.pid + ":" + gated), gated }) + "\n");
+    } catch { socket.destroy(); }
+  });
+});
+server.on("error", (error) => { console.error(error.message); process.exit(126); });
+if (process.platform !== "win32") {
+  try { unlinkSync(address); } catch (error) { if (error.code !== "ENOENT") throw error; }
+  process.on("exit", () => { try { unlinkSync(address); } catch {} });
+}
+server.listen(address, () => { if (process.platform !== "win32") chmodSync(address, 0o600); });
+`;
+async function guardianProof(pid, resume, expectedToken = resume) {
+	if (!expectedToken) return void 0;
+	const token = expectedToken;
+	const nonce = (0, node_crypto.randomBytes)(32).toString("hex");
+	const sign = (value) => (0, node_crypto.createHmac)("sha256", token).update(value).digest("hex");
+	const address = guardianAddress(process.platform, pid, process.getuid?.() ?? 0);
+	return new Promise((resolve, reject) => {
+		const socket = (0, node_net.connect)(address);
+		let data = "";
+		const fail = (error) => {
+			socket.destroy();
+			reject(error);
+		};
+		socket.setTimeout(2e3, () => fail(/* @__PURE__ */ new Error("Process ownership observation timed out")));
+		socket.on("connect", () => socket.write(JSON.stringify({
+			nonce,
+			resume: resume ? sign(nonce + ":resume") : void 0
+		}) + "\n"));
+		socket.on("data", (chunk) => {
+			data += chunk.toString();
+			if (data.length > 1024) fail(/* @__PURE__ */ new Error("Invalid process ownership response"));
+		});
+		socket.on("error", (error) => {
+			if (["ENOENT", "ECONNREFUSED"].includes(error.code ?? "")) resolve(void 0);
+			else reject(error);
+		});
+		socket.on("end", () => {
+			try {
+				resolve(parseGuardianProof(data, pid, nonce, token));
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+/** Malformed observation is an error; an authenticated identity mismatch is unowned. */
+function parseGuardianProof(source, pid, nonce, token) {
+	const proof = JSON.parse(source);
+	if (!proof || typeof proof !== "object" || !("pid" in proof) || typeof proof.pid !== "number" || !("gated" in proof) || typeof proof.gated !== "boolean" || !("digest" in proof) || typeof proof.digest !== "string") throw new Error("Invalid process ownership response");
+	const expected = (0, node_crypto.createHmac)("sha256", token).update(nonce + ":" + pid + ":" + proof.gated).digest("hex");
+	if (proof.pid !== pid || proof.digest !== expected) return void 0;
+	return {
+		pid,
+		token,
+		gated: proof.gated
+	};
+}
+/** Pure launch construction, including case-insensitive Windows environment keys. */
+function launchCommand(platform, node, command, args, limits, environment, token) {
+	const portable = platform !== "linux";
+	const env = Object.fromEntries(Object.entries(environment).filter(([key]) => !["WARLOCK_PROCESS_TOKEN", "WARLOCK_PROCESS_LAUNCH"].includes(platform === "win32" ? key.toUpperCase() : key)));
+	env.WARLOCK_PROCESS_TOKEN = token;
+	if (portable) env.WARLOCK_PROCESS_LAUNCH = JSON.stringify([command, ...args]);
+	const executable = portable ? node : command;
+	const arguments_ = portable ? ["-e", guardianScript] : args;
+	return {
+		file: platform === "win32" ? executable : "/bin/sh",
+		args: platform === "win32" ? arguments_ : [
+			"-c",
+			launcher(limits, platform),
+			"warlock-process",
+			executable,
+			...arguments_
+		],
+		env
+	};
+}
+
+//#endregion
+//#region ../../packages/process/src/platform.ts
+var UnsupportedProcessPlatformError = class extends Error {
+	platform;
+	constructor(platform) {
+		super(`Process supervision is unsupported on ${platform}`);
+		this.platform = platform;
+		this.name = "UnsupportedProcessPlatformError";
+	}
+};
+function supported(platform) {
+	if (![
+		"linux",
+		"darwin",
+		"win32"
+	].includes(platform)) throw new UnsupportedProcessPlatformError(platform);
+}
+function validPid(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 1) throw new Error("Invalid process PID");
+}
+/** Apple ps(1): lstart uses strftime %c. LC_ALL=C gives %a %b %e %H:%M:%S %Y.
+* https://github.com/apple-oss-distributions/adv_cmds/blob/main/ps/ps.1
+* https://github.com/apple-oss-distributions/adv_cmds/blob/main/ps/print.c (lstarted)
+* https://github.com/apple-oss-distributions/Libc/blob/main/stdtime/FreeBSD/timelocal.c (_C_time_locale)
+*/
+function parseDarwinStart(source) {
+	const match = /^(Sun|Mon|Tue|Wed|Thu|Fri|Sat) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/.exec(source.trim());
+	if (!match) throw new Error("Invalid macOS process start time");
+	const [, weekday, month, day, hour, minute, second, year] = match;
+	const monthIndex = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(" ").indexOf(month ?? "");
+	const date = new Date(Date.UTC(Number(year), monthIndex, Number(day), Number(hour), Number(minute), Number(second)));
+	if (date.getUTCFullYear() !== Number(year) || date.getUTCMonth() !== monthIndex || date.getUTCDate() !== Number(day) || date.getUTCHours() !== Number(hour) || date.getUTCMinutes() !== Number(minute) || date.getUTCSeconds() !== Number(second) || "Sun Mon Tue Wed Thu Fri Sat".split(" ")[date.getUTCDay()] !== weekday) throw new Error("Invalid macOS process start time");
+	return String(date.getTime() / 1e3);
+}
+function darwinCommand(pid, tree = false) {
+	validPid(pid);
+	return {
+		file: "/bin/ps",
+		args: [
+			...tree ? ["-ax"] : ["-p", String(pid)],
+			"-o",
+			"pid=,ppid=,pgid=,state=,rss=,lstart="
+		],
+		env: {
+			LC_ALL: "C",
+			TZ: "UTC"
+		}
+	};
+}
+function parseDarwinRows(source) {
+	return source.trim() ? source.trim().split("\n").map((line) => {
+		const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
+		if (!match) throw new Error("Invalid macOS process observation");
+		return {
+			pid: Number(match[1]),
+			parent: Number(match[2]),
+			group: Number(match[3]),
+			state: match[4] ?? "",
+			rss: Number(match[5]) * 1024,
+			start: parseDarwinStart(match[6] ?? "")
+		};
+	}) : [];
+}
+/** CIM CreationDate is a DateTime; serialize UTC ticks as text, never a locale date
+* or JSON number (100ns ticks exceed Number's precision). WorkingSetSize is bytes.
+* https://learn.microsoft.com/en-us/windows/win32/cimwin32prov/win32-process
+*/
+function windowsCommand(pid, tree = false) {
+	validPid(pid);
+	return {
+		file: "powershell.exe",
+		args: [
+			"-NoLogo",
+			"-NoProfile",
+			"-NonInteractive",
+			"-Command",
+			[
+				"$ErrorActionPreference = 'Stop'",
+				`$rows = @(${`Get-CimInstance Win32_Process${tree ? "" : ` -Filter 'ProcessId=${pid}'`}`} | ForEach-Object {`,
+				`if ([int]$_.ProcessId -eq ${pid} -and $null -eq $_.CreationDate) { throw 'Cannot read process creation time' }`,
+				"if ($null -ne $_.CreationDate) {",
+				"[pscustomobject]@{ pid = [int]$_.ProcessId; parent = [int]$_.ParentProcessId; start = $_.CreationDate.ToUniversalTime().Ticks.ToString([Globalization.CultureInfo]::InvariantCulture); rss = [double]$_.WorkingSetSize }",
+				"}",
+				"})",
+				"ConvertTo-Json -InputObject $rows -Compress"
+			].join("\n")
+		]
+	};
+}
+function parseWindowsRows(source) {
+	const value = JSON.parse(source.replace(/^\uFEFF/, ""));
+	if (!Array.isArray(value)) throw new Error("Invalid Windows process observation");
+	return value.map((row) => {
+		if (!row || typeof row !== "object" || !("pid" in row) || typeof row.pid !== "number" || !Number.isSafeInteger(row.pid) || row.pid < 0 || !("parent" in row) || typeof row.parent !== "number" || !Number.isSafeInteger(row.parent) || row.parent < 0 || !("start" in row) || typeof row.start !== "string" || !/^\d{18}$/.test(row.start) || !("rss" in row) || typeof row.rss !== "number" || !Number.isFinite(row.rss) || row.rss < 0) throw new Error("Invalid Windows process observation");
+		return {
+			pid: row.pid,
+			parent: row.parent,
+			start: row.start,
+			rss: row.rss,
+			group: row.pid,
+			state: "R"
+		};
+	});
+}
+function taskkillCommand(pid) {
+	validPid(pid);
+	return {
+		file: "taskkill.exe",
+		args: [
+			"/PID",
+			String(pid),
+			"/T",
+			"/F"
+		]
+	};
+}
+function treeMemory(rows, pid) {
+	const root = rows.find((row) => row.pid === pid);
+	if (!root) return 0;
+	const included = /* @__PURE__ */ new Map([[pid, root]]);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const row of rows) {
+			const parent = included.get(row.parent);
+			if (!included.has(row.pid) && parent && BigInt(row.start) >= BigInt(parent.start)) {
+				included.set(row.pid, row);
+				changed = true;
+			}
+		}
+	}
+	return [...included.values()].reduce((total, row) => total + row.rss, 0);
+}
+/** All OS effects are injected; foreign-platform specs never execute real commands. */
+async function portableIdentity(platform, pid, token, execute, readProof) {
+	validPid(pid);
+	const command = platform === "darwin" ? darwinCommand : windowsCommand;
+	const parse = platform === "darwin" ? parseDarwinRows : parseWindowsRows;
+	const rows = parse(await execute(command(pid, token)));
+	const before = rows.find((row) => row.pid === pid);
+	if (!before || /^[ZX]/.test(before.state)) return void 0;
+	if (!token) return before;
+	const proof = await readProof(pid);
+	const after = parse(await execute(command(pid))).find((row) => row.pid === pid);
+	if (!after || after.start !== before.start || after.group !== before.group || /^[ZX]/.test(after.state)) return void 0;
+	return {
+		start: after.start,
+		group: after.group,
+		state: proof?.pid === pid && proof.gated ? "T" : after.state,
+		rss: treeMemory(rows, pid),
+		token: proof?.pid === pid ? proof.token : void 0
+	};
+}
+
+//#endregion
+//#region ../../packages/process/src/identity.ts
+const execute = (0, node_util.promisify)(node_child_process.execFile);
+async function executeCommand(command) {
+	const { stdout } = await execute(command.file, command.args, {
+		env: {
+			...process.env,
+			...command.env
+		},
+		timeout: 5e3,
+		maxBuffer: 4194304,
+		windowsHide: true
+	});
+	return stdout;
+}
+const TOKEN_ENV = "WARLOCK_PROCESS_TOKEN";
+function statFields(stat) {
+	return stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+}
+/**
+* A task that is exiting has already released its memory map (stat field 23,
+* vsize, reads 0) before it turns into a zombie. Linux then reports its /proc
+* files as root-owned, so it is never a live child to verify or signal.
+*/
+function exiting(fields) {
+	return ["Z", "X"].includes(fields[0] ?? "") || fields[20] === "0";
+}
+/** /proc fields: https://man7.org/linux/man-pages/man5/proc_pid_stat.5.html */
+async function identity(pid, token = false, expectedToken) {
+	if (!Number.isSafeInteger(pid) || pid <= 1) return void 0;
+	try {
+		if (process.platform === "linux") {
+			const fields = statFields(await (0, node_fs_promises.readFile)(`/proc/${pid}/stat`, "utf8"));
+			const state = fields[0];
+			const start = fields[19];
+			if (!state || !start || exiting(fields)) return void 0;
+			const boot = (await (0, node_fs_promises.readFile)("/proc/sys/kernel/random/boot_id", "utf8")).trim();
+			const status = await (0, node_fs_promises.readFile)(`/proc/${pid}/status`, "utf8");
+			let environment = "";
+			if (token) try {
+				environment = await (0, node_fs_promises.readFile)(`/proc/${pid}/environ`, "utf8");
+			} catch (error) {
+				if (error.code !== "EACCES") throw error;
+				const now = statFields(await (0, node_fs_promises.readFile)(`/proc/${pid}/stat`, "utf8"));
+				if (now[19] !== start || exiting(now)) return void 0;
+				throw error;
+			}
+			const after = statFields(await (0, node_fs_promises.readFile)(`/proc/${pid}/stat`, "utf8"));
+			if (after[19] !== start || after[2] !== fields[2] || exiting(after)) return void 0;
+			return {
+				start: `${boot}:${start}`,
+				group: Number(fields[2]),
+				state: after[0] ?? state,
+				rss: Number(/^VmRSS:\s+(\d+)/m.exec(status)?.[1] ?? 0) * 1024,
+				token: environment.split("\0").find((entry) => entry.startsWith(`${TOKEN_ENV}=`))?.slice(22)
+			};
+		}
+		if (process.platform === "darwin" || process.platform === "win32") return await portableIdentity(process.platform, pid, token, executeCommand, (selected) => guardianProof(selected, void 0, expectedToken));
+		return;
+	} catch (error) {
+		const code = error.code;
+		if (process.platform === "linux" && ["ENOENT", "ESRCH"].includes(String(code)) || process.platform === "darwin" && code === 1 && !error.stdout?.trim()) return void 0;
+		throw error;
+	}
+}
+var ProcessNotOwnedError = class extends Error {
+	pid;
+	constructor(pid) {
+		super(`Process ${pid} does not have a verified supervisor identity`);
+		this.pid = pid;
+		this.name = "ProcessNotOwnedError";
+	}
+};
+async function owns(entry) {
+	const current = await identity(entry.pid, true, entry.token);
+	return current?.start === entry.start && current.token === entry.token && current.group === entry.pid;
+}
+
+//#endregion
+//#region ../../packages/process/src/registry.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function strings(value) {
+	return record(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function parseRegistry(source, owner) {
+	const value = JSON.parse(source);
+	if (!record(value) || value.version !== 1 || value.owner !== owner || !Array.isArray(value.entries)) throw new Error("Invalid process registry or different owner");
+	const entries = [];
+	for (const entry of value.entries) {
+		if (!record(entry) || entry.owner !== owner || typeof entry.pid !== "number" || !Number.isSafeInteger(entry.pid) || Number(entry.pid) <= 1 || typeof entry.token !== "string" || !/^[a-f0-9]{64}$/.test(entry.token) || typeof entry.start !== "string" || typeof entry.type !== "string" || typeof entry.command !== "string" || !Array.isArray(entry.args) || !entry.args.every((arg) => typeof arg === "string") || !strings(entry.labels) || typeof entry.startedAt !== "number" || !Number.isFinite(entry.startedAt) || entry.startedAt < 0 || !record(entry.limits) || !Object.entries(entry.limits).every(([key, limit]) => [
+			"timeoutMs",
+			"memoryBytes",
+			"cpuSeconds",
+			"virtualMemoryBytes"
+		].includes(key) && typeof limit === "number" && Number.isSafeInteger(limit) && limit > 0) || ![
+			"cgroup-v2",
+			"rlimit-polling",
+			"rss-polling"
+		].includes(String(entry.enforcement)) || typeof entry.peakMemoryBytes !== "number" || !Number.isFinite(entry.peakMemoryBytes) || entry.peakMemoryBytes < 0 || entry.cgroup !== void 0 && typeof entry.cgroup !== "string" || entry.gated !== void 0 && typeof entry.gated !== "boolean") throw new Error("Invalid process registry entry");
+		entries.push(entry);
+	}
+	if (new Set(entries.map((entry) => entry.pid)).size !== entries.length) throw new Error("Duplicate registry PID");
+	return entries;
+}
+/** One writer per registry. A crash leaves a lease which only a dead identity can release. */
+var Registry = class {
+	file;
+	owner;
+	queue = Promise.resolve();
+	locked = false;
+	constructor(file, owner) {
+		this.file = file;
+		this.owner = owner;
+	}
+	async open() {
+		await (0, node_fs_promises.mkdir)(node_path.default.dirname(this.file), {
+			recursive: true,
+			mode: 448
+		});
+		const self = await identity(process.pid);
+		if (!self) throw new Error("Cannot verify registry writer identity");
+		const lock = `${this.file}.lock`;
+		try {
+			await (0, node_fs_promises.mkdir)(lock, { mode: 448 });
+		} catch (error) {
+			if (error.code !== "EEXIST") throw error;
+			const reclaim = `${lock}.reclaim`;
+			await (0, node_fs_promises.mkdir)(reclaim, { mode: 448 });
+			try {
+				const lease = JSON.parse(await (0, node_fs_promises.readFile)(node_path.default.join(lock, "writer.json"), "utf8"));
+				if (!record(lease) || typeof lease.pid !== "number" || typeof lease.start !== "string") throw new Error("Invalid registry writer lease; inspect it manually");
+				if ((await identity(lease.pid))?.start === lease.start) throw new Error("Process registry is already in use");
+				const stale = `${lock}.${(0, node_crypto.randomBytes)(8).toString("hex")}`;
+				await (0, node_fs_promises.rename)(lock, stale);
+				await (0, node_fs_promises.rm)(stale, { recursive: true });
+				await (0, node_fs_promises.mkdir)(lock, { mode: 448 });
+			} finally {
+				await (0, node_fs_promises.rm)(reclaim, { recursive: true });
+			}
+		}
+		this.locked = true;
+		try {
+			await (0, node_fs_promises.writeFile)(node_path.default.join(lock, "writer.json"), JSON.stringify({
+				pid: process.pid,
+				start: self.start
+			}), { mode: 384 });
+			try {
+				return parseRegistry(await (0, node_fs_promises.readFile)(this.file, "utf8"), this.owner);
+			} catch (error) {
+				if (error.code === "ENOENT") return [];
+				throw error;
+			}
+		} catch (error) {
+			await this.close();
+			throw error;
+		}
+	}
+	save(entries) {
+		const source = JSON.stringify({
+			version: 1,
+			owner: this.owner,
+			entries
+		}, null, 2) + "\n";
+		const next = this.queue.then(async () => {
+			const temporary = `${this.file}.${(0, node_crypto.randomBytes)(8).toString("hex")}.tmp`;
+			try {
+				await (0, node_fs_promises.writeFile)(temporary, source, {
+					mode: 384,
+					flag: "wx"
+				});
+				await (0, node_fs_promises.rename)(temporary, this.file);
+			} finally {
+				await (0, node_fs_promises.rm)(temporary, { force: true });
+			}
+		});
+		this.queue = next.catch(() => void 0);
+		return next;
+	}
+	async close() {
+		await this.queue;
+		if (this.locked) {
+			await (0, node_fs_promises.rm)(`${this.file}.lock`, { recursive: true });
+			this.locked = false;
+		}
+	}
+};
+
+//#endregion
+//#region ../../packages/process/src/supervisor.ts
+function info(entry) {
+	const { token: _token, start: _start, cgroup: _cgroup, gated: _gated, ...visible } = entry;
+	return structuredClone(visible);
+}
+function validateFilter(filter) {
+	if (!filter || typeof filter !== "object" || Array.isArray(filter) || Object.keys(filter).some((key) => key !== "labels")) throw new Error("Only label filters are supported");
+	if (filter.labels !== void 0 && (filter.labels === null || typeof filter.labels !== "object" || Array.isArray(filter.labels) || !Object.values(filter.labels).every((value) => typeof value === "string"))) throw new Error("Labels must be string key/value pairs");
+}
+function matches(entry, filter) {
+	return Object.entries(filter.labels ?? {}).every(([key, value]) => entry.labels[key] === value);
+}
+function supervisor(options) {
+	for (const option of ["owner", "registry"]) if (!options || typeof options[option] !== "string" || !options[option].trim()) throw new TypeError(`Invalid supervisor configuration: ${option} must be a nonempty string`);
+	validateLimits(options.defaults ?? {});
+	options = {
+		...options,
+		defaults: { ...options.defaults }
+	};
+	const pollMs = options.pollIntervalMs ?? 100;
+	const graceMs = options.stopGraceMs ?? 1e3;
+	if (!Number.isSafeInteger(pollMs) || pollMs < 10 || !Number.isSafeInteger(graceMs) || graceMs < 0) throw new Error("Invalid polling interval or stop grace period");
+	const registry = new Registry(node_path.default.resolve(options.registry), options.owner);
+	const entries = /* @__PURE__ */ new Map();
+	const active = /* @__PURE__ */ new Map();
+	let ready;
+	let closing = false;
+	let shutdown;
+	let queue = Promise.resolve();
+	function serial(operation) {
+		const next = queue.then(operation);
+		queue = next.catch(() => void 0);
+		return next;
+	}
+	async function open() {
+		supported(process.platform);
+		if (closing) throw new Error("Supervisor has shut down");
+		ready ??= registry.open().then((saved) => {
+			for (const entry of saved) {
+				delete entry.cgroup;
+				entries.set(entry.pid, entry);
+			}
+		});
+		await ready;
+	}
+	const save = () => registry.save([...entries.values()]);
+	async function signal(entry, value) {
+		if (!await owns(entry)) throw new ProcessNotOwnedError(entry.pid);
+		if (process.platform !== "linux" && value === "SIGCONT") {
+			const proof = await guardianProof(entry.pid, entry.token);
+			if (!proof || proof.token !== entry.token || proof.gated) throw new ProcessNotOwnedError(entry.pid);
+			return;
+		}
+		if (process.platform === "win32") {
+			try {
+				await executeCommand(taskkillCommand(entry.pid));
+			} catch (error) {
+				if (await owns(entry)) throw error;
+			}
+			return;
+		}
+		try {
+			process.kill(-entry.pid, value);
+		} catch (error) {
+			if (error.code !== "ESRCH") throw error;
+		}
+	}
+	async function stopEntry(entry, reason = "stopped") {
+		const tracked = active.get(entry.pid);
+		let running;
+		if (!tracked) {
+			if (!await owns(entry)) throw new ProcessNotOwnedError(entry.pid);
+			entry.cgroup = await recoveredCgroup(entry.pid, entry.token);
+			running = track(entry);
+		} else running = tracked;
+		if (running.finished) return running.finish(null, null);
+		if (running.stopping) return running.stopping;
+		const stopping = (async () => {
+			if (!await owns(entry)) throw new ProcessNotOwnedError(entry.pid);
+			running.reason ??= reason;
+			await signal(entry, "SIGTERM");
+			const deadline = Date.now() + graceMs;
+			while (await owns(entry)) {
+				if (Date.now() >= deadline) {
+					await signal(entry, "SIGKILL");
+					break;
+				}
+				await (0, node_timers_promises.setTimeout)(20);
+			}
+			const killedDeadline = Date.now() + 5e3;
+			while (await owns(entry)) {
+				if (Date.now() >= killedDeadline) throw new Error(`Process ${entry.pid} did not exit after SIGKILL`);
+				await (0, node_timers_promises.setTimeout)(20);
+			}
+			await running.finish(null, null);
+		})();
+		running.stopping = stopping;
+		try {
+			await stopping;
+		} catch (error) {
+			running.stopping = void 0;
+			if (error instanceof ProcessNotOwnedError && !await identity(entry.pid)) {
+				await running.finish(null, null);
+				return;
+			}
+			throw error;
+		}
+	}
+	function track(entry, streams) {
+		let resolveExit = () => void 0;
+		let rejectExit = () => void 0;
+		const exited = new Promise((resolve, reject) => {
+			resolveExit = resolve;
+			rejectExit = reject;
+		});
+		exited.catch(() => void 0);
+		const stdout = streams?.stdout ?? new node_stream.PassThrough();
+		const stderr = streams?.stderr ?? new node_stream.PassThrough();
+		const stdin = streams?.stdin ?? new node_stream.PassThrough();
+		let finishing;
+		const running = {
+			entry,
+			finished: false,
+			adopted: !streams,
+			fail: (error) => rejectExit(error),
+			handle: {
+				pid: entry.pid,
+				stdout,
+				stderr,
+				stdin,
+				exited,
+				stop: () => serial(async () => {
+					if (!running.finished) await stopEntry(entry);
+				})
+			},
+			finish(code, sig) {
+				finishing ??= (async () => {
+					running.finished = true;
+					clearInterval(running.timer);
+					if (entry.cgroup) {
+						const memory = await cgroupMemory(entry.cgroup);
+						entry.peakMemoryBytes = Math.max(entry.peakMemoryBytes, memory.peak);
+						if (memory.oom) running.reason = "memory-cap";
+						await cleanCgroup(entry.cgroup);
+					}
+					active.delete(entry.pid);
+					entries.delete(entry.pid);
+					try {
+						await save();
+						resolveExit({
+							reason: running.reason ?? "exit",
+							code,
+							signal: sig,
+							peakMemoryBytes: entry.peakMemoryBytes
+						});
+					} catch (error) {
+						rejectExit(error);
+						throw error;
+					}
+					if (!streams) {
+						stdout.end();
+						stderr.end();
+						stdin.end();
+					}
+				})();
+				return finishing;
+			}
+		};
+		active.set(entry.pid, running);
+		return running;
+	}
+	function monitor(running) {
+		if (running.finished) return;
+		let sampling = false;
+		const sample = async () => {
+			if (sampling || running.finished) return;
+			sampling = true;
+			try {
+				const entry = running.entry;
+				const current = await identity(entry.pid, true, entry.token);
+				if (running.finished) return;
+				if (current?.start !== entry.start || current.token !== entry.token || current.group !== entry.pid) {
+					if (!current) {
+						if (running.adopted) await running.finish(null, null);
+					} else throw new ProcessNotOwnedError(entry.pid);
+					return;
+				}
+				entry.peakMemoryBytes = Math.max(entry.peakMemoryBytes, current.rss);
+				if (entry.cgroup) {
+					const memory = await cgroupMemory(entry.cgroup);
+					if (running.finished) return;
+					entry.peakMemoryBytes = Math.max(entry.peakMemoryBytes, memory.peak);
+					if (memory.oom) running.reason = "memory-cap";
+				}
+				if (entry.limits.memoryBytes && entry.peakMemoryBytes > entry.limits.memoryBytes) await stopEntry(entry, "memory-cap");
+				else if (entry.limits.timeoutMs && Date.now() - entry.startedAt >= entry.limits.timeoutMs) await stopEntry(entry, "timeout");
+			} finally {
+				sampling = false;
+			}
+		};
+		running.timer = setInterval(() => {
+			sample().catch((error) => {
+				clearInterval(running.timer);
+				if (!running.finished) running.fail(error);
+			});
+		}, pollMs);
+		running.timer.unref();
+	}
+	async function launch(input, terminal) {
+		await open();
+		if ([...entries.keys()].some((pid) => !active.has(pid))) throw new Error("Call recover() before spawning with an existing registry");
+		if (typeof input.command !== "string" || !input.command || typeof input.kind !== "string" || !input.kind) throw new Error("kind and command are required");
+		validateFilter({ labels: input.labels });
+		if (terminal && [input.columns ?? 80, input.rows ?? 24].some((size) => !Number.isSafeInteger(size) || size <= 0)) throw new Error("Terminal dimensions must be positive safe integers");
+		const limits = {
+			...options.defaults,
+			...input.limits
+		};
+		validateLimits(limits);
+		const token = (0, node_crypto.randomBytes)(32).toString("hex");
+		const { file: executable, args, env } = launchCommand(process.platform, process.execPath, input.command, input.args ?? [], limits, {
+			...process.env,
+			...input.env
+		}, token);
+		let pid;
+		let streams;
+		let terminalProcess;
+		let exit;
+		let spawnError;
+		let running;
+		const onExit = (code, sig) => {
+			exit = {
+				code,
+				signal: sig
+			};
+			if (running) running.finish(code, sig).catch(() => void 0);
+		};
+		if (terminal) {
+			terminalProcess = (await import("node-pty")).spawn(executable, args, {
+				cwd: input.cwd,
+				env: Object.fromEntries(Object.entries(env).filter((pair) => pair[1] !== void 0)),
+				cols: input.columns ?? 80,
+				rows: input.rows ?? 24,
+				name: "xterm-256color"
+			});
+			pid = terminalProcess.pid;
+			const output = new node_stream.PassThrough();
+			const errors = new node_stream.PassThrough();
+			const instance = terminalProcess;
+			const dataSubscription = instance.onData((data) => output.write(data));
+			const inputStream = new node_stream.Writable({ write(chunk, _encoding, callback) {
+				instance.write(chunk.toString());
+				callback();
+			} });
+			const exitSubscription = instance.onExit((event) => {
+				dataSubscription.dispose();
+				exitSubscription.dispose();
+				output.end();
+				errors.end();
+				inputStream.end();
+				onExit(event.exitCode, event.signal ? String(event.signal) : null);
+			});
+			streams = {
+				stdout: output,
+				stderr: errors,
+				stdin: inputStream
+			};
+		} else {
+			const child = (0, node_child_process.spawn)(executable, args, {
+				cwd: input.cwd,
+				env,
+				detached: process.platform !== "win32",
+				windowsHide: true,
+				stdio: "pipe"
+			});
+			child.on("error", (error) => {
+				spawnError = error;
+			});
+			child.on("exit", onExit);
+			if (!child.pid) throw new Error("Could not start process");
+			pid = child.pid;
+			streams = {
+				stdout: child.stdout,
+				stderr: child.stderr,
+				stdin: child.stdin
+			};
+		}
+		let entry;
+		try {
+			const deadline = Date.now() + 5e3;
+			let current = await identity(pid, true, token);
+			while (!current?.state.startsWith("T") || current.token !== token) {
+				if (spawnError) throw spawnError;
+				if (exit || Date.now() >= deadline) throw new Error("Child failed to reach the resource setup gate");
+				await (0, node_timers_promises.setTimeout)(10);
+				current = await identity(pid, true, token);
+			}
+			if (current.group !== pid) throw new Error("Child did not create an isolated process group");
+			entry = {
+				pid,
+				owner: options.owner,
+				type: input.kind,
+				command: input.command,
+				args: [...input.args ?? []],
+				labels: { ...input.labels },
+				startedAt: Date.now(),
+				limits,
+				enforcement: process.platform === "win32" ? "rss-polling" : "rlimit-polling",
+				peakMemoryBytes: current.rss,
+				token,
+				start: current.start,
+				gated: true
+			};
+			entry.cgroup = await attachCgroup(pid, token, limits, options.cgroupRoot);
+			if (entry.cgroup) entry.enforcement = "cgroup-v2";
+			entries.set(pid, entry);
+			await save();
+			running = track(entry, streams);
+			await signal(entry, "SIGCONT");
+			delete entry.gated;
+			await save();
+			monitor(running);
+			if (terminalProcess) {
+				const instance = terminalProcess;
+				return {
+					...running.handle,
+					write: (data) => instance.write(data),
+					resize: (columns, rows) => instance.resize(columns, rows)
+				};
+			}
+			return running.handle;
+		} catch (error) {
+			const current = await identity(pid, true, token);
+			if (current?.token === token) {
+				const failed = {
+					pid,
+					token,
+					start: current.start
+				};
+				if (await owns(failed)) try {
+					if (process.platform === "win32") await executeCommand(taskkillCommand(pid));
+					else process.kill(-pid, "SIGKILL");
+				} catch {}
+			}
+			if (entry && !running) {
+				entries.delete(pid);
+				await save();
+			}
+			if (entry?.cgroup) await cleanCgroup(entry.cgroup);
+			throw error;
+		}
+	}
+	return {
+		spawn: (input) => serial(() => launch(input, false)),
+		spawnPty: (input) => serial(async () => await launch(input, true)),
+		list: (filter = {}) => serial(async () => {
+			validateFilter(filter);
+			await open();
+			return [...entries.values()].filter((entry) => matches(entry, filter)).map(info);
+		}),
+		stop: (filter = {}) => serial(async () => {
+			validateFilter(filter);
+			await open();
+			for (const entry of [...entries.values()].filter((entry) => matches(entry, filter))) await stopEntry(entry);
+		}),
+		stopPid: (pid) => serial(async () => {
+			await open();
+			const entry = entries.get(pid);
+			if (!entry) throw new ProcessNotOwnedError(pid);
+			await stopEntry(entry);
+		}),
+		recover: (recovery = {}) => serial(async () => {
+			await open();
+			const result = {
+				adopted: [],
+				stopped: [],
+				cleared: []
+			};
+			for (const entry of [...entries.values()]) {
+				if (active.has(entry.pid)) continue;
+				if (!await owns(entry)) {
+					entries.delete(entry.pid);
+					result.cleared.push(entry.pid);
+					continue;
+				}
+				entry.cgroup = await recoveredCgroup(entry.pid, entry.token);
+				entry.enforcement = entry.cgroup ? "cgroup-v2" : process.platform === "win32" ? "rss-polling" : "rlimit-polling";
+				if (await recovery.keep?.(info(entry))) {
+					monitor(track(entry));
+					if (entry.gated) {
+						await signal(entry, "SIGCONT");
+						delete entry.gated;
+					}
+					result.adopted.push(entry.pid);
+				} else {
+					await stopEntry(entry);
+					result.stopped.push(entry.pid);
+				}
+			}
+			await save();
+			return result;
+		}),
+		stopAll() {
+			shutdown ??= serial(async () => {
+				await open();
+				closing = true;
+				try {
+					const errors = [];
+					for (const entry of [...entries.values()]) try {
+						if (await owns(entry)) await stopEntry(entry);
+						else {
+							const running = active.get(entry.pid);
+							if (running) await running.finish(null, null);
+							else entries.delete(entry.pid);
+						}
+					} catch (error) {
+						errors.push(error);
+					}
+					await save();
+					if (errors.length) throw new AggregateError(errors, "Some owned processes could not be stopped");
+				} finally {
+					await registry.close();
+				}
+			});
+			return shutdown;
+		}
+	};
+}
+
+//#endregion
+exports.ProcessNotOwnedError = ProcessNotOwnedError;
+exports.UnsupportedProcessPlatformError = UnsupportedProcessPlatformError;
+exports.supervisor = supervisor;
+//# sourceMappingURL=index.cjs.map