@stim-cli/server 1.14.0 → 1.15.0

package/dist/stim-server.mjs

@@ -1,4424 +1,9 @@
 #!/usr/bin/env node
-import { _ as PUSH_TOKEN_PATTERN, b as TOUCH_PHASES, c as INPUT_BUTTONS, f as MAX_LOG_TAIL, g as PUSH_EVENTS, l as LOG_LEVELS, n as CAPABILITIES, o as FRAME_EDGE, s as FRAME_FPS, t as ACTIONS, u as LOG_SOURCES, v as RELOAD_PLATFORMS, y as ROTATE_DIRECTIONS } from "./protocol-IroIg8Td.mjs";
-import { createRequire } from "node:module";
-import { accessSync, appendFileSync, constants, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, statSync, statfsSync, watch, writeFileSync } from "node:fs";
-import { availableParallelism, cpus, homedir, hostname, loadavg, tmpdir, totalmem } from "node:os";
-import { parseArgs } from "node:util";
-import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
-import { basename, delimiter, dirname, join } from "node:path";
-import { compileGrep, isJsonObject, loadConfig, readJsonObject } from "@stim-cli/core/state";
-import { createHash, randomBytes } from "node:crypto";
-import { configDir, withDirLock } from "@stim-cli/core";
-import { createServer } from "node:http";
-import { isIP } from "node:net";
-import { WebSocketServer } from "ws";
-import { connect } from "node:http2";
-import { fileURLToPath } from "node:url";
-import { createInterface } from "node:readline";
-//#region src/environment.ts
-function parseEnvironment(output) {
-	const environment = {};
-	for (const entry of output.split("\0")) {
-		const equals = entry.indexOf("=");
-		if (equals > 0) environment[entry.slice(0, equals)] = entry.slice(equals + 1);
-	}
-	return environment;
-}
-/**
-* The login shell's environment, as Stim Desktop captures it: a process started by launchd lacks the
-* PATH entries and variables such as ANDROID_HOME that the shell profile sets. The shell writes to a
-* file because a background process started by a profile can keep a pipe open after the shell exits.
-*/
-function loginShellEnvironment() {
-	const dir = mkdtempSync(join(tmpdir(), "stim-server-env-"));
-	const file = join(dir, "env");
-	try {
-		spawnSync(process.env.SHELL || "/bin/zsh", [
-			"-lic",
-			"command env -0 > \"$1\"",
-			"stim-server",
-			file
-		], {
-			stdio: "ignore",
-			timeout: 15e3
-		});
-		const environment = parseEnvironment(readFileSync(file, "utf8"));
-		return Object.keys(environment).length ? environment : null;
-	} catch {
-		return null;
-	} finally {
-		rmSync(dir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-function bundledStim() {
-	const manifest = createRequire(import.meta.url).resolve("stim/package.json");
-	const pkg = JSON.parse(readFileSync(manifest, "utf8"));
-	return {
-		cli: join(dirname(manifest), pkg.bin.stim),
-		version: pkg.version
-	};
-}
-//#endregion
-//#region src/registry.ts
-const PAIRING_TTL_MS = 3e5;
-function serverDir() {
-	return join(configDir(), "server");
-}
-function devicesFile() {
-	return join(serverDir(), "devices.json");
-}
-function pairingFile() {
-	return join(serverDir(), "pairing.json");
-}
-function hashToken(token) {
-	return createHash("sha256").update(token).digest("hex");
-}
-function newToken() {
-	return randomBytes(32).toString("base64url");
-}
-function parseIdentity(value) {
-	if (!isJsonObject(value)) return null;
-	if (value.kind === "local") return { kind: "local" };
-	const { nodeId, nodeName, user } = value;
-	if (value.kind === "tailnet" && typeof nodeId === "string" && typeof nodeName === "string" && typeof user === "string") return {
-		kind: "tailnet",
-		nodeId,
-		nodeName,
-		user
-	};
-	return null;
-}
-function parseCapabilities(value) {
-	return Array.isArray(value) ? CAPABILITIES.filter((capability) => value.includes(capability)) : [];
-}
-function capabilitiesFor(control) {
-	return control ? ["read", "control"] : ["read"];
-}
-const pushToken$1 = new RegExp(PUSH_TOKEN_PATTERN);
-function parsePush(value) {
-	if (!isJsonObject(value)) return null;
-	const { token, events, agentOnly, ref, registeredAt } = value;
-	if (typeof token !== "string" || !pushToken$1.test(token) || typeof ref !== "string") return null;
-	if (!Array.isArray(events) || typeof registeredAt !== "string") return null;
-	return {
-		token,
-		events: PUSH_EVENTS.filter((event) => events.includes(event)),
-		agentOnly: agentOnly === true,
-		ref,
-		registeredAt
-	};
-}
-function parseDevice(value) {
-	if (!isJsonObject(value)) return null;
-	const { id, name, tokenHash, pairedAt, lastSeenAt } = value;
-	const identity = parseIdentity(value.identity);
-	if (typeof id !== "string" || typeof name !== "string" || typeof tokenHash !== "string" || !identity) return null;
-	if (typeof pairedAt !== "string") return null;
-	const push = parsePush(value.push);
-	return {
-		id,
-		name,
-		tokenHash,
-		identity,
-		pairedAt,
-		lastSeenAt: typeof lastSeenAt === "string" ? lastSeenAt : null,
-		capabilities: parseCapabilities(value.capabilities),
-		...push ? { push } : {}
-	};
-}
-function readDevices() {
-	const devices = readJsonObject(devicesFile())?.devices;
-	return Array.isArray(devices) ? devices.flatMap((entry) => parseDevice(entry) ?? []) : [];
-}
-function readPairings() {
-	const tokens = readJsonObject(pairingFile())?.tokens;
-	if (!Array.isArray(tokens)) return [];
-	return tokens.flatMap((entry) => isJsonObject(entry) && typeof entry.tokenHash === "string" && typeof entry.expiresAt === "string" ? [{
-		tokenHash: entry.tokenHash,
-		expiresAt: entry.expiresAt,
-		capabilities: "capabilities" in entry ? parseCapabilities(entry.capabilities) : capabilitiesFor(false)
-	}] : []);
-}
-function writeJson(file, value) {
-	const temporary = join(dirname(file), `.${basename(file)}.${process.pid}.tmp`);
-	try {
-		writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 384 });
-		renameSync(temporary, file);
-	} catch (error) {
-		rmSync(temporary, { force: true });
-		throw error;
-	}
-}
-function transaction(fn) {
-	return withDirLock(join(serverDir(), "registry.lock"), fn, { ensureParent: () => mkdirSync(serverDir(), {
-		recursive: true,
-		mode: 448
-	}) });
-}
-function unexpired(record, now) {
-	return Date.parse(record.expiresAt) > now;
-}
-/** The device that spends the token gets `capabilities`. */
-function createPairingToken(now = Date.now(), capabilities = capabilitiesFor(false)) {
-	const token = newToken();
-	const expiresAt = new Date(now + PAIRING_TTL_MS).toISOString();
-	transaction(() => {
-		const pending = readPairings().filter((record) => unexpired(record, now));
-		writeJson(pairingFile(), {
-			version: 1,
-			tokens: [...pending, {
-				tokenHash: hashToken(token),
-				expiresAt,
-				capabilities
-			}]
-		});
-	});
-	return {
-		token,
-		expiresAt
-	};
-}
-function sameNode(a, b) {
-	if (a.kind === "local" || b.kind === "local") return a.kind === b.kind;
-	return a.nodeId === b.nodeId;
-}
-function spendPairingToken(token, name, identity, now = Date.now()) {
-	return transaction(() => {
-		const pairings = readPairings();
-		const tokenHash = hashToken(token);
-		const match = pairings.find((record) => record.tokenHash === tokenHash);
-		const pending = pairings.filter((record) => record !== match && unexpired(record, now));
-		if (pending.length !== pairings.length) writeJson(pairingFile(), {
-			version: 1,
-			tokens: pending
-		});
-		if (!match) return {
-			ok: false,
-			reason: "pairing-unknown"
-		};
-		if (!unexpired(match, now)) return {
-			ok: false,
-			reason: "pairing-expired"
-		};
-		const deviceToken = newToken();
-		const at = new Date(now).toISOString();
-		const device = {
-			id: randomBytes(4).toString("hex"),
-			name,
-			tokenHash: hashToken(deviceToken),
-			identity,
-			pairedAt: at,
-			lastSeenAt: at,
-			capabilities: match.capabilities
-		};
-		writeJson(devicesFile(), {
-			version: 1,
-			devices: [...readDevices(), device]
-		});
-		return {
-			ok: true,
-			device,
-			deviceToken
-		};
-	});
-}
-function authenticateDevice(token, identity, now = Date.now()) {
-	return transaction(() => {
-		const devices = readDevices();
-		const tokenHash = hashToken(token);
-		const device = devices.find((entry) => entry.tokenHash === tokenHash);
-		if (!device) return {
-			ok: false,
-			reason: "device-unknown"
-		};
-		if (!sameNode(device.identity, identity)) return {
-			ok: false,
-			reason: "node-mismatch"
-		};
-		device.lastSeenAt = new Date(now).toISOString();
-		writeJson(devicesFile(), {
-			version: 1,
-			devices
-		});
-		return {
-			ok: true,
-			device
-		};
-	});
-}
-function grantDevice(id, capabilities) {
-	return transaction(() => {
-		const devices = readDevices();
-		const device = devices.find((entry) => entry.id === id);
-		if (!device) return false;
-		device.capabilities = capabilities;
-		writeJson(devicesFile(), {
-			version: 1,
-			devices
-		});
-		return true;
-	});
-}
-/**
-* Sets or, with null, removes a device's push registration, taking the token from any other pairing, such as the
-* same phone's previous one. False when the device is no longer paired.
-*/
-function setDevicePush(id, push) {
-	return transaction(() => {
-		const devices = readDevices();
-		const device = devices.find((entry) => entry.id === id);
-		if (!device) return false;
-		for (const other of devices) if (push && other.push?.token === push.token) delete other.push;
-		if (push) device.push = push;
-		else delete device.push;
-		writeJson(devicesFile(), {
-			version: 1,
-			devices
-		});
-		return true;
-	});
-}
-/** Removes every registration of a push token the push service no longer delivers to. */
-function dropPushToken(token) {
-	transaction(() => {
-		const devices = readDevices();
-		let changed = false;
-		for (const device of devices) {
-			if (device.push?.token !== token) continue;
-			delete device.push;
-			changed = true;
-		}
-		if (changed) writeJson(devicesFile(), {
-			version: 1,
-			devices
-		});
-	});
-}
-function revokeDevice(id) {
-	return transaction(() => {
-		const devices = readDevices();
-		const remaining = devices.filter((device) => device.id !== id);
-		if (remaining.length === devices.length) return false;
-		writeJson(devicesFile(), {
-			version: 1,
-			devices: remaining
-		});
-		return true;
-	});
-}
-//#endregion
-//#region src/actions.ts
-function parseAction(params) {
-	if (!isJsonObject(params)) return {
-		code: "bad-request",
-		message: "params must be an object."
-	};
-	const { action, workspace, platform, ...rest } = params;
-	if (typeof action !== "string" || !ACTIONS.includes(action)) return {
-		code: "unknown-action",
-		message: `Unknown action ${JSON.stringify(action)}. Actions: ${ACTIONS.join(", ")}.`
-	};
-	if (typeof workspace !== "string") return {
-		code: "bad-request",
-		message: "params.workspace must be an environment path from a status payload."
-	};
-	const extra = Object.keys(rest);
-	if (action === "stop" && platform !== void 0) extra.push("platform");
-	if (extra.length) return {
-		code: "bad-request",
-		message: `${action} does not take ${extra.join(", ")}.`
-	};
-	if (action === "stop") return { action: {
-		action,
-		workspace
-	} };
-	if (platform !== void 0 && !RELOAD_PLATFORMS.includes(platform)) return {
-		code: "bad-request",
-		message: `platform must be one of ${RELOAD_PLATFORMS.join(", ")}.`
-	};
-	return { action: {
-		action: "reload",
-		workspace,
-		...platform ? { platform } : {}
-	} };
-}
-function actionArgs(action) {
-	if (action.action === "stop") return ["stop", "--json"];
-	return [
-		"reload",
-		...action.platform ? [action.platform] : [],
-		"--json"
-	];
-}
-/** The JSON object the command printed, and on failure the message and remedy it printed, if any. */
-function actionOutcome(outcome) {
-	let printed = null;
-	try {
-		printed = JSON.parse(outcome.stdout?.trim() ?? "");
-	} catch {
-		printed = null;
-	}
-	if (outcome.ok) return isJsonObject(printed) ? {
-		ok: true,
-		output: printed
-	} : {
-		ok: false,
-		error: {
-			code: "action-failed",
-			message: "The command printed output that is not a JSON object."
-		}
-	};
-	if (isJsonObject(printed) && typeof printed.message === "string") {
-		const code = typeof printed.code === "string" ? `${printed.code}: ` : "";
-		const remedy = typeof printed.remedy === "string" ? ` ${printed.remedy}` : "";
-		return {
-			ok: false,
-			error: {
-				code: "action-failed",
-				message: `${code}${printed.message}${remedy}`
-			}
-		};
-	}
-	return {
-		ok: false,
-		error: {
-			code: "action-failed",
-			message: outcome.message
-		}
-	};
-}
-function auditFile() {
-	return join(serverDir(), "actions.ndjson");
-}
-function appendAudit(record) {
-	mkdirSync(serverDir(), {
-		recursive: true,
-		mode: 448
-	});
-	appendFileSync(auditFile(), `${JSON.stringify(record)}\n`, { mode: 384 });
-}
-function readAudit() {
-	let text;
-	try {
-		text = readFileSync(auditFile(), "utf8");
-	} catch {
-		return [];
-	}
-	return text.split("\n").flatMap((line) => {
-		try {
-			const value = JSON.parse(line);
-			return isJsonObject(value) ? [value] : [];
-		} catch {
-			return [];
-		}
-	});
-}
-//#endregion
-//#region src/stim-command.ts
-const KILL_GRACE_MS = 1e3;
-function terminate(child) {
-	if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve();
-	child.kill("SIGTERM");
-	const timer = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
-	return new Promise((resolve) => {
-		const done = () => {
-			clearTimeout(timer);
-			resolve();
-		};
-		child.once("exit", done);
-		child.once("close", done);
-	});
-}
-function runStim(stimCli, env, args, cwd, limits) {
-	const child = spawn(process.execPath, [stimCli, ...args], {
-		cwd,
-		env,
-		stdio: [
-			"ignore",
-			"pipe",
-			"pipe"
-		]
-	});
-	const label = `stim ${args[0]}`;
-	let cancelled = false;
-	let failure = null;
-	const chunks = [];
-	let size = 0;
-	let stderr = "";
-	const release = () => {
-		child.stdout.destroy();
-		child.stderr.destroy();
-	};
-	const fail = (message) => {
-		if (failure) return;
-		failure = message;
-		release();
-		terminate(child);
-	};
-	const timer = setTimeout(() => {
-		if (child.exitCode !== null || child.signalCode !== null) return release();
-		fail(`${label} did not finish within ${limits.timeoutMs / 1e3} s.`);
-	}, limits.timeoutMs);
-	child.stdout.on("data", (chunk) => {
-		size += chunk.length;
-		if (size > limits.maxOutputBytes) return fail(`${label} printed more than ${limits.maxOutputBytes} bytes.`);
-		chunks.push(chunk);
-	});
-	child.stderr.setEncoding("utf8");
-	child.stderr.on("data", (chunk) => {
-		stderr = (stderr + chunk).slice(-2e3);
-	});
-	return {
-		outcome: new Promise((resolve) => {
-			const settle = (result) => {
-				clearTimeout(timer);
-				if (!cancelled) resolve(result);
-			};
-			child.on("error", (error) => settle({
-				ok: false,
-				message: `${label} could not start (${error.message}).`
-			}));
-			child.on("close", (code, signal) => {
-				if (failure) return settle({
-					ok: false,
-					message: failure
-				});
-				if (code === 0) return settle({
-					ok: true,
-					stdout: Buffer.concat(chunks).toString("utf8")
-				});
-				const detail = stderr.trim();
-				settle({
-					ok: false,
-					message: `${label} exited (${signal ?? `code ${code}`})${detail ? `: ${detail}` : ""}`,
-					stdout: Buffer.concat(chunks).toString("utf8")
-				});
-			});
-		}),
-		cancel: () => {
-			cancelled = true;
-			clearTimeout(timer);
-			return terminate(child);
-		}
-	};
-}
-//#endregion
-//#region src/video.ts
-const FIXED_HEADER_BYTES = 21;
-/** The binary WebSocket message for `unit` on `subscription`; see `VideoPacket` in protocol.ts for the layout. */
-function videoPacket(subscription, sequence, unit) {
-	const id = Buffer.from(subscription, "ascii");
-	const header = Buffer.alloc(FIXED_HEADER_BYTES + id.length);
-	header.writeUInt8(1, 0);
-	const posture = unit.posture === "folded" ? 2 : unit.posture === "unfolded" ? 4 : 0;
-	header.writeUInt8((unit.keyframe ? 1 : 0) | posture, 1);
-	header.writeUInt16BE(header.length, 2);
-	header.writeUInt32BE(sequence >>> 0, 4);
-	header.writeDoubleBE(unit.capturedAt, 8);
-	header.writeUInt16BE(unit.width, 16);
-	header.writeUInt16BE(unit.height, 18);
-	header.writeUInt8(id.length, 20);
-	id.copy(header, FIXED_HEADER_BYTES);
-	return Buffer.concat([header, unit.data]);
-}
-const DEFAULT_VIDEO_LIMITS = {
-	congestedBytes: 262144,
-	startBitrate: 3e6,
-	minBitrate: 25e4,
-	maxBitrate: 8e6,
-	recoverMs: 2e3
-};
-/**
-* Decides, for one subscriber, whether each access unit goes out. A subscriber starts waiting for a keyframe.
-* When its socket backs up it drops everything until the next keyframe, because a P-frame is useless without
-* the frames before it; `congested` is reported once per episode.
-*/
-var VideoGate = class {
-	waiting = true;
-	congestedBytes;
-	constructor(congestedBytes) {
-		this.congestedBytes = congestedBytes;
-	}
-	admit(unit, bufferedBytes) {
-		if (bufferedBytes > this.congestedBytes) {
-			if (this.waiting) return "drop";
-			this.waiting = true;
-			return "congested";
-		}
-		if (this.waiting && !unit.keyframe) return "drop";
-		this.waiting = false;
-		return "send";
-	}
-	/** The client lost its decoder state; drop until the keyframe it asked for. */
-	reset() {
-		this.waiting = true;
-	}
-};
-/**
-* One encoder's bitrate, shared by all subscribers of a device: halved on congestion at most once per `recoverMs`,
-* and raised by a quarter after `recoverMs` without congestion.
-*/
-var Bitrate = class {
-	value;
-	calmSince;
-	cutAt = -Infinity;
-	limits;
-	constructor(limits, now) {
-		this.limits = limits;
-		this.value = limits.startBitrate;
-		this.calmSince = now;
-	}
-	get current() {
-		return this.value;
-	}
-	/** Called while any subscriber is congested. Returns the new bitrate when it changed. */
-	congested(now) {
-		this.calmSince = now;
-		if (now - this.cutAt < this.limits.recoverMs) return null;
-		this.cutAt = now;
-		return this.set(Math.max(this.limits.minBitrate, Math.round(this.value / 2)));
-	}
-	/** Returns the new bitrate when it changed. */
-	tick(now) {
-		if (now - this.calmSince < this.limits.recoverMs) return null;
-		this.calmSince = now;
-		return this.set(Math.min(this.limits.maxBitrate, Math.round(this.value * 1.25)));
-	}
-	set(next) {
-		if (next === this.value) return null;
-		this.value = next;
-		return next;
-	}
-};
-//#endregion
-//#region src/frame-helper.ts
-const DEFAULT_FRAME_HINT = {
-	fps: FRAME_FPS.default,
-	maxEdge: FRAME_EDGE.default
-};
-const SOURCES_DIR = fileURLToPath(new URL("./stim-frames/", import.meta.url));
-const BUILD_TIMEOUT_MS = 18e4;
-const VERSION_TIMEOUT_MS = 3e4;
-const MAX_MESSAGE_BYTES = 16777216;
-const FRAME_MESSAGE = 1;
-const NOTICE_MESSAGE = 2;
-const VIDEO_MESSAGE = 3;
-const VIDEO_HEADER_BYTES = 14;
-const KEYFRAME_INTERVAL_MS = 250;
-/** Runs the compiler in its own process group, so a timeout or `signal` also stops `swift-frontend` and `ld`. */
-function run(file, args, env, timeoutMs, signal) {
-	return new Promise((resolve, reject) => {
-		const child = spawn(file, args, {
-			env,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			detached: true
-		});
-		let output = "";
-		let stopped = null;
-		const stop = (reason) => {
-			stopped ??= reason;
-			try {
-				process.kill(-child.pid, "SIGKILL");
-			} catch {}
-		};
-		const timer = setTimeout(() => stop(`${file} ${args[0]} did not finish within ${timeoutMs / 1e3} s.`), timeoutMs);
-		const abort = () => stop(`${file} ${args[0]} was stopped with the server.`);
-		signal?.addEventListener("abort", abort);
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => output = (output + chunk).slice(-4e3));
-		child.stderr.on("data", (chunk) => output = (output + chunk).slice(-4e3));
-		child.on("error", (error) => {
-			clearTimeout(timer);
-			signal?.removeEventListener("abort", abort);
-			reject(/* @__PURE__ */ new Error(`${file} could not start (${error.message}).`));
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			signal?.removeEventListener("abort", abort);
-			if (stopped) reject(new Error(stopped));
-			else if (code === 0) resolve(output);
-			else reject(/* @__PURE__ */ new Error(`${file} ${args[0]} exited (code ${code}): ${output.trim()}`));
-		});
-	});
-}
-/**
-* Compiles the `stim-frames` helper from the Swift sources shipped in `dist/stim-frames/` into
-* `$STIM_HOME/server/helpers/`, named by a hash of the sources and the compiler version. Resolves to the
-* helper's path, or rejects with the reason it cannot be built.
-*/
-async function buildFrameHelper(env, signal, sourcesDir = SOURCES_DIR) {
-	if (process.platform !== "darwin") throw new Error("stim-frames runs only on macOS.");
-	const sources = readdirSync(sourcesDir).filter((name) => name.endsWith(".swift")).toSorted().map((name) => join(sourcesDir, name));
-	if (!sources.length) throw new Error(`${sourcesDir} has no Swift sources.`);
-	return compiled("stim-frames", sources, await run("xcrun", ["swiftc", "--version"], env, VERSION_TIMEOUT_MS, signal), async (output) => {
-		await run("xcrun", [
-			"swiftc",
-			"-O",
-			"-swift-version",
-			"5",
-			"-module-name",
-			"StimFrames",
-			"-o",
-			output,
-			...sources
-		], env, BUILD_TIMEOUT_MS, signal);
-	});
-}
-/**
-* Compiles `sim-fold`, which folds or unfolds an iPhone Duo from inside the simulator, from the Stim Desktop
-* sources shipped in `dist/stim-frames/`, the way Stim Desktop's bundle script builds it.
-*/
-async function buildFoldHelper(env, signal, sourcesDir = SOURCES_DIR) {
-	if (process.platform !== "darwin") throw new Error("sim-fold runs only on macOS.");
-	const source = join(sourcesDir, "sim-fold.m");
-	const entitlements = join(sourcesDir, "sim-fold.entitlements");
-	const clang = [
-		"-sdk",
-		"iphonesimulator",
-		"clang"
-	];
-	const version = await run("xcrun", [...clang, "--version"], env, VERSION_TIMEOUT_MS, signal);
-	return compiled("sim-fold", [source, entitlements], version, async (output) => {
-		await run("xcrun", [
-			...clang,
-			"-fobjc-arc",
-			"-arch",
-			"arm64",
-			"-arch",
-			"x86_64",
-			"-mios-simulator-version-min=18.0",
-			"-framework",
-			"Foundation",
-			source,
-			"-o",
-			output,
-			`-Wl,-sectcreate,__TEXT,__entitlements,${entitlements}`
-		], env, BUILD_TIMEOUT_MS, signal);
-		await run("codesign", [
-			"--force",
-			"--sign",
-			"-",
-			output
-		], env, VERSION_TIMEOUT_MS, signal);
-	});
-}
-async function compiled(name, inputs, version, compile) {
-	const hash = createHash("sha256").update(version);
-	for (const input of inputs) hash.update(basename(input)).update(readFileSync(input));
-	const dir = join(serverDir(), "helpers");
-	const helper = join(dir, `${name}-${hash.digest("hex").slice(0, 16)}`);
-	if (existsSync(helper)) return helper;
-	mkdirSync(dir, {
-		recursive: true,
-		mode: 448
-	});
-	const output = `${helper}.tmp-${process.pid}-${randomBytes(4).toString("hex")}`;
-	try {
-		await compile(output);
-		renameSync(output, helper);
-	} finally {
-		rmSync(output, { force: true });
-	}
-	return helper;
-}
-/**
-* One `stim-frames` process per device, shared by its subscribers and stopped `lingerMs` after the last of them
-* leaves, unchanged meanwhile, so a subscriber that comes back within that time gets the latest frame at once. It runs
-* at the highest fps and the largest edge any subscriber asked for; each subscriber paces its own frames. The
-* helper exits when its stdin closes, so it cannot outlive the server. `lit` turns the display the helper
-* reports it streams into a posture, which the frames and access units after it carry.
-*/
-var HelperSource = class {
-	listeners = /* @__PURE__ */ new Map();
-	child;
-	last = null;
-	config = "";
-	stopped = false;
-	notice = null;
-	keyboard = null;
-	stderr = "";
-	ended;
-	bitrate = new Bitrate(DEFAULT_VIDEO_LIMITS, Date.now());
-	keyframeAt = -Infinity;
-	keyframeTimer = null;
-	lit;
-	posture;
-	lingerMs;
-	lingerTimer = null;
-	constructor(helper, device, env, ended, lingerMs, lit) {
-		this.ended = ended;
-		this.lingerMs = lingerMs;
-		this.lit = lit;
-		const id = device.platform === "ios" ? device.udid : device.serial;
-		this.child = spawn(helper, [device.platform, id], {
-			env,
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		});
-		this.child.stdin.on("error", () => {});
-		this.child.stderr.setEncoding("utf8");
-		this.child.stderr.on("data", (chunk) => {
-			this.stderr = (this.stderr + chunk).slice(-1e3);
-		});
-		this.readMessages();
-		this.child.on("error", (error) => this.fail(`stim-frames could not start (${error.message}).`));
-		this.child.on("close", (code, signal) => {
-			const detail = this.notice ?? this.stderr.trim();
-			this.fail(`stim-frames exited (${signal ?? `code ${code}`})${detail ? `: ${detail}` : ""}`);
-		});
-	}
-	/** A null `hint` keeps the helper running for input without asking for frames. */
-	add(listener, hint) {
-		if (this.lingerTimer) clearTimeout(this.lingerTimer);
-		this.lingerTimer = null;
-		this.listeners.set(listener, hint);
-		this.configure();
-		if (listener.video) this.keyframe();
-		else if (this.last) listener.frame(this.last);
-		return () => {
-			if (!this.listeners.delete(listener)) return;
-			if (this.listeners.size > 0) this.configure();
-			else this.lingerTimer = setTimeout(() => void this.stop(), this.lingerMs);
-		};
-	}
-	stop() {
-		if (this.stopped) return Promise.resolve();
-		this.stopped = true;
-		if (this.keyframeTimer) clearTimeout(this.keyframeTimer);
-		if (this.lingerTimer) clearTimeout(this.lingerTimer);
-		this.listeners.clear();
-		this.ended();
-		this.child.stdin.end();
-		return terminate(this.child);
-	}
-	/** Asks for at most one keyframe per {@link KEYFRAME_INTERVAL_MS}; a request inside the interval is sent at its end. */
-	keyframe() {
-		if (this.stopped || this.keyframeTimer) return;
-		const wait = this.keyframeAt + KEYFRAME_INTERVAL_MS - Date.now();
-		if (wait > 0) {
-			this.keyframeTimer = setTimeout(() => {
-				this.keyframeTimer = null;
-				this.keyframe();
-			}, wait);
-			return;
-		}
-		this.keyframeAt = Date.now();
-		this.child.stdin.write("{\"keyframe\":true}\n");
-	}
-	congested() {
-		if (this.bitrate.congested(Date.now()) !== null) this.configure();
-	}
-	send(command) {
-		if (!this.stopped) this.child.stdin.write(`${JSON.stringify(command)}\n`);
-	}
-	configure() {
-		if (this.listeners.size === 0) return;
-		const watching = [...this.listeners].flatMap(([listener, hint]) => hint ? [{
-			listener,
-			hint
-		}] : []);
-		const hints = watching.map(({ hint }) => hint);
-		const jpegFps = watching.flatMap(({ listener, hint }) => listener.video ? [] : [hint.fps]);
-		const config = JSON.stringify({
-			fps: Math.max(0, ...hints.map((hint) => hint.fps)),
-			maxEdge: Math.max(FRAME_EDGE.min, ...hints.map((hint) => hint.maxEdge)),
-			jpeg: jpegFps.length > 0,
-			...jpegFps.length ? { jpegFps: Math.max(...jpegFps) } : {},
-			video: jpegFps.length < hints.length,
-			bitrate: this.bitrate.current
-		});
-		if (!jpegFps.length) this.last = null;
-		if (config === this.config || this.stopped) return;
-		this.config = config;
-		this.child.stdin.write(`${config}\n`);
-	}
-	fail(message) {
-		if (this.stopped) return;
-		const listeners = [...this.listeners.keys()];
-		this.stop();
-		for (const listener of listeners) listener.failed(message);
-	}
-	readMessages() {
-		let buffer = Buffer.alloc(0);
-		this.child.stdout.on("data", (chunk) => {
-			buffer = buffer.length ? Buffer.concat([buffer, chunk]) : chunk;
-			while (buffer.length >= 4) {
-				const length = buffer.readUInt32BE(0);
-				if (length < 1 || length > MAX_MESSAGE_BYTES) {
-					this.child.stdout.removeAllListeners("data");
-					return this.fail("stim-frames wrote a malformed message.");
-				}
-				if (buffer.length < 4 + length) break;
-				const body = buffer.subarray(4, 4 + length);
-				buffer = buffer.subarray(4 + length);
-				if (body[0] === FRAME_MESSAGE && body.length > 5) this.frame(body);
-				else if (body[0] === VIDEO_MESSAGE && body.length > VIDEO_HEADER_BYTES) this.video(body);
-				else if (body[0] === NOTICE_MESSAGE) this.readNotice(body.subarray(1).toString("utf8"));
-			}
-		});
-	}
-	frame(body) {
-		if (this.stopped) return;
-		this.last = {
-			width: body.readUInt16BE(1),
-			height: body.readUInt16BE(3),
-			capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			data: body.subarray(5).toString("base64"),
-			...this.posture ? { posture: this.posture } : {}
-		};
-		for (const listener of this.listeners.keys()) if (!listener.video) listener.frame(this.last);
-	}
-	video(body) {
-		if (this.stopped) return;
-		const unit = {
-			keyframe: (body[1] & 1) !== 0,
-			capturedAt: body.readDoubleBE(2),
-			width: body.readUInt16BE(10),
-			height: body.readUInt16BE(12),
-			data: body.subarray(VIDEO_HEADER_BYTES),
-			...this.posture ? { posture: this.posture } : {}
-		};
-		if (this.bitrate.tick(Date.now()) !== null) this.configure();
-		for (const listener of this.listeners.keys()) listener.video?.(unit);
-	}
-	readNotice(text) {
-		try {
-			const notice = JSON.parse(text);
-			const error = notice?.error;
-			if (typeof error === "string") this.notice = error;
-			const keyboard = notice?.keyboard;
-			if (keyboard === "yes" || keyboard === "no") this.keyboard = keyboard === "yes";
-			const inputError = notice?.inputError;
-			if (typeof inputError === "string") console.error(`stim-server: stim-frames: ${inputError}`);
-			const display = notice?.display;
-			if (this.lit && typeof display === "number") this.posture = this.lit(display);
-		} catch {}
-	}
-};
-//#endregion
-//#region src/frames.ts
-const DEFAULT_FRAME_LIMITS = {
-	toolTimeoutMs: 3e4,
-	slowCaptureMs: 3e3,
-	failureBackoffMs: 3e3,
-	maxConsecutiveFailures: 3,
-	lingerMs: 1e4
-};
-const MIN_INTERVAL_MS = 200;
-const MAX_INTERVAL_MS = 1e3;
-const MAX_CAPTURES = 2;
-const MAX_EDGE = 1280;
-const JPEG_QUALITY = 70;
-function deviceKey(device) {
-	return device.platform === "ios" ? `ios:${device.udid}` : `android:${device.serial}`;
-}
-function ownedDevice(payload, target, attached) {
-	const slot = target.slot ?? "default";
-	if (!Array.isArray(payload.environments)) return "stim status printed a payload without environments.";
-	const environment = payload.environments.find((candidate) => candidate.path === target.workspace);
-	if (!environment) return `${target.workspace} is not a Stim workspace on this Mac.`;
-	const devices = slot === "default" ? {
-		ios: environment.ios,
-		android: environment.android
-	} : environment.slots?.find((candidate) => candidate.slot === slot);
-	const where = `${target.platform} in slot ${slot} of ${target.workspace}`;
-	if (target.platform === "ios") {
-		const sim = devices?.ios;
-		if (!sim?.owned) return `No simulator Stim owns runs ${where}.`;
-		if (sim.state !== "Booted") return `The simulator for ${where} is ${sim.state}, not booted.`;
-		return {
-			platform: "ios",
-			udid: sim.udid,
-			foldable: /\bDuo\b/.test(sim.name ?? "")
-		};
-	}
-	const emulator = devices?.android;
-	if (!emulator?.owned || emulator.physical) return `No emulator Stim owns runs ${where}.`;
-	if (emulator.state === "unknown" && attached?.startsWith("android:")) return {
-		platform: "android",
-		serial: attached.slice(8)
-	};
-	if (emulator.state !== "detected" || !emulator.serial) return `The emulator for ${where} is not running.`;
-	return {
-		platform: "android",
-		serial: emulator.serial
-	};
-}
-function jpegSize(bytes) {
-	if (bytes[0] !== 255 || bytes[1] !== 216) return null;
-	let offset = 2;
-	while (offset + 9 <= bytes.length) {
-		if (bytes[offset] !== 255) return null;
-		const marker = bytes[offset + 1];
-		if (marker === 255) {
-			offset += 1;
-			continue;
-		}
-		if (marker === 1 || marker >= 208 && marker <= 216) {
-			offset += 2;
-			continue;
-		}
-		if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) return {
-			height: bytes.readUInt16BE(offset + 5),
-			width: bytes.readUInt16BE(offset + 7)
-		};
-		offset += 2 + bytes.readUInt16BE(offset + 2);
-	}
-	return null;
-}
-/** A rejection with `transient: true` is a timeout on a machine that is merely busy, not a broken capturer. */
-function timeoutError(message) {
-	return Object.assign(new Error(message), { transient: true });
-}
-function isTransient(error) {
-	return error instanceof Error && error.transient === true;
-}
-function runTool(file, args, env, running, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		const child = spawn(file, args, {
-			env,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		});
-		running.add(child);
-		child.once("close", () => running.delete(child));
-		const chunks = [];
-		let stderr = "";
-		const timer = setTimeout(() => {
-			terminate(child);
-			reject(timeoutError(`${file} ${args[0]} did not finish within ${timeoutMs / 1e3} s.`));
-		}, timeoutMs);
-		child.stdout.on("data", (chunk) => chunks.push(chunk));
-		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (chunk) => {
-			stderr = (stderr + chunk).slice(-1e3);
-		});
-		child.on("error", (error) => {
-			clearTimeout(timer);
-			reject(/* @__PURE__ */ new Error(`${file} could not start (${error.message}).`));
-		});
-		child.on("close", (code) => {
-			clearTimeout(timer);
-			if (code === 0) resolve(Buffer.concat(chunks));
-			else reject(Object.assign(/* @__PURE__ */ new Error(`${file} ${args.join(" ")} exited (code ${code}): ${stderr.trim()}`), { stderr }));
-		});
-	});
-}
-async function stopTools(running, tmp) {
-	await Promise.all([...running].map((child) => terminate(child)));
-	if (tmp) rmSync(tmp, {
-		recursive: true,
-		force: true
-	});
-}
-/**
-* Without `--display`, simctl captures the first panel it finds; `primary` is the panel CoreDevice reports as
-* primary. A simctl that rejects `primary` gets the default display instead.
-*
-* An iPhone Duo lights one of two panels: `primary` is the cover, lit when folded, and `primary-1` the inner
-* panel, lit when unfolded; the other one's framebuffer is all black. `litPanels` remembers the lit panel per
-* simulator across subscriptions, and a black capture tries the other panel.
-*/
-function simulatorCapturer(device, env, limits, litPanels) {
-	let tmp = null;
-	let display = ["--display=primary"];
-	let closed = false;
-	const running = /* @__PURE__ */ new Set();
-	const screenshot = async (panel) => {
-		tmp ??= mkdtempSync(join(serverDir(), "frames-"));
-		const output = join(tmp, "frame.jpg");
-		await runTool("xcrun", [
-			"simctl",
-			"io",
-			device.udid,
-			"screenshot",
-			"--type=jpeg",
-			...panel,
-			output
-		], env, running, limits.toolTimeoutMs);
-		return readFileSync(output);
-	};
-	const isBlack = async (jpeg) => {
-		const input = join(tmp, "check.jpg");
-		const output = join(tmp, "check.bmp");
-		writeFileSync(input, jpeg);
-		await runTool("sips", [
-			"-s",
-			"format",
-			"bmp",
-			"-z",
-			"24",
-			"24",
-			input,
-			"--out",
-			output
-		], env, running, limits.toolTimeoutMs);
-		return bmpIsBlack(readFileSync(output));
-	};
-	const open = () => {
-		if (closed) throw new Error("The capture was stopped.");
-	};
-	const captureDuo = async () => {
-		const lit = litPanels.get(device.udid) ?? "primary";
-		const jpeg = await screenshot([`--display=${lit}`]);
-		open();
-		if (!await isBlack(jpeg)) {
-			litPanels.set(device.udid, lit);
-			return {
-				raw: jpeg,
-				jpeg: async () => jpeg,
-				posture: POSTURES[lit]
-			};
-		}
-		const other = lit === "primary" ? "primary-1" : "primary";
-		open();
-		const otherJpeg = await screenshot([`--display=${other}`]);
-		open();
-		if (await isBlack(otherJpeg)) return {
-			raw: jpeg,
-			jpeg: async () => jpeg
-		};
-		litPanels.set(device.udid, other);
-		return {
-			raw: otherJpeg,
-			jpeg: async () => otherJpeg,
-			posture: POSTURES[other]
-		};
-	};
-	return {
-		capture: async () => {
-			if (device.foldable) return captureDuo();
-			let jpeg;
-			try {
-				jpeg = await screenshot(display);
-			} catch (error) {
-				if (closed || !display.length || !/display/i.test(error.stderr ?? "")) throw error;
-				display = [];
-				jpeg = await screenshot(display);
-			}
-			return {
-				raw: jpeg,
-				jpeg: async () => jpeg
-			};
-		},
-		close: () => {
-			closed = true;
-			return stopTools(running, tmp);
-		}
-	};
-}
-/** The Duo's panels in the order the helper indexes CoreSimulator's displays, by screen ID. */
-const DUO_PANELS = ["primary", "primary-1"];
-const POSTURES = {
-	primary: "folded",
-	"primary-1": "unfolded"
-};
-/** Whether every pixel of an uncompressed 24- or 32-bit BMP, as `sips -s format bmp` writes it, is black. */
-function bmpIsBlack(bmp) {
-	if (bmp.length < 54 || bmp.toString("latin1", 0, 2) !== "BM") throw new Error("sips did not write a BMP image.");
-	const offset = bmp.readUInt32LE(10);
-	const bytesPerPixel = bmp.readUInt16LE(28) / 8;
-	for (let at = offset; at + 3 <= bmp.length; at += bytesPerPixel) if (bmp[at] > 8 || bmp[at + 1] > 8 || bmp[at + 2] > 8) return false;
-	return true;
-}
-/**
-* The emulator writes `pid_<pid>.ini` to this directory on macOS when it was started with `-grpc`, which
-* Stim passes when it boots an owned AVD (#1064).
-*/
-function emulatorEndpoint(env, serial) {
-	const console = /^emulator-(\d+)$/.exec(serial)?.[1];
-	if (!console || !env.HOME) return null;
-	const dir = join(env.HOME, "Library/Caches/TemporaryItems/avd/running");
-	let names;
-	try {
-		names = readdirSync(dir);
-	} catch {
-		return null;
-	}
-	for (const name of names) {
-		const pid = /^pid_(\d+)\.ini$/.exec(name)?.[1];
-		if (!pid) continue;
-		try {
-			process.kill(Number(pid), 0);
-		} catch {
-			continue;
-		}
-		let text;
-		try {
-			text = readFileSync(join(dir, name), "utf8");
-		} catch {
-			continue;
-		}
-		const values = new Map(text.split(/\r?\n/).flatMap((line) => {
-			const at = line.indexOf("=");
-			return at > 0 ? [[line.slice(0, at), line.slice(at + 1)]] : [];
-		}));
-		const grpcPort = Number(values.get("grpc.port"));
-		if (values.get("port.serial") === console && Number.isInteger(grpcPort) && grpcPort > 0) return {
-			grpcPort,
-			token: values.get("grpc.token") ?? null
-		};
-	}
-	return null;
-}
-function varint(value) {
-	const out = [];
-	let rest = value;
-	while (rest >= 128) {
-		out.push(rest & 127 | 128);
-		rest = Math.floor(rest / 128);
-	}
-	out.push(rest);
-	return out;
-}
-function* protoFields(bytes) {
-	let offset = 0;
-	const readVarint = () => {
-		let result = 0;
-		let scale = 1;
-		for (;;) {
-			if (offset >= bytes.length) throw new Error("truncated protobuf");
-			const byte = bytes[offset++];
-			result += (byte & 127) * scale;
-			if (byte < 128) return result;
-			scale *= 128;
-		}
-	};
-	while (offset < bytes.length) {
-		const key = readVarint();
-		const field = Math.floor(key / 8);
-		const type = key % 8;
-		if (type === 0) yield {
-			field,
-			varint: readVarint()
-		};
-		else if (type === 2) {
-			const length = readVarint();
-			if (offset + length > bytes.length) throw new Error("truncated protobuf");
-			yield {
-				field,
-				bytes: bytes.subarray(offset, offset + length)
-			};
-			offset += length;
-		} else if (type === 1) offset += 8;
-		else if (type === 5) offset += 4;
-		else throw new Error(`unsupported protobuf wire type ${type}`);
-	}
-}
-function grpcMessage(message) {
-	const header = Buffer.alloc(5);
-	header.writeUInt32BE(message.length, 1);
-	return Buffer.concat([header, Buffer.from(message)]);
-}
-function grpcReply(body, method) {
-	if (body.length < 5 || body[0] !== 0) throw new Error(`${method} returned no message.`);
-	return body.subarray(5, 5 + body.readUInt32BE(1));
-}
-/**
-* `ImageFormat` and `Image` in the emulator's emulator_controller.proto; format 0 is PNG. The reply's
-* format carries `foldedDisplay` (field 7) while a foldable is folded.
-*/
-function screenshotReply(body) {
-	let png = null;
-	let folded = false;
-	for (const entry of protoFields(grpcReply(body, "getScreenshot"))) {
-		if (entry.field === 4 && "bytes" in entry) png = Buffer.from(entry.bytes);
-		if (entry.field === 1 && "bytes" in entry) folded = [...protoFields(entry.bytes)].some((format) => format.field === 7);
-	}
-	if (!png) throw new Error("getScreenshot returned no image.");
-	return {
-		png,
-		folded
-	};
-}
-/**
-* `PhysicalModelValue` for POSTURE (PhysicalType 16), whose one float is a `Posture.PostureValue`; 1 to 5
-* are real postures, so any of them means the emulator has a hinge.
-*/
-function hasHinge(body) {
-	for (const entry of protoFields(grpcReply(body, "getPhysicalModel"))) {
-		if (entry.field === 2 && "varint" in entry && entry.varint !== 0) return false;
-		if (entry.field !== 3 || !("bytes" in entry)) continue;
-		for (const value of protoFields(entry.bytes)) {
-			if (value.field !== 1 || !("bytes" in value) || value.bytes.length < 4) continue;
-			const posture = Math.round(value.bytes.readFloatLE(0));
-			return posture >= 1 && posture <= 5;
-		}
-	}
-	return false;
-}
-function grpcSession(endpoint) {
-	const session = connect(`http://127.0.0.1:${endpoint.grpcPort}`);
-	session.on("error", () => {});
-	return session;
-}
-function grpcCall(session, endpoint, serial, method, requestBody, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		const request = session.request({
-			":method": "POST",
-			":path": `/android.emulation.control.EmulatorController/${method}`,
-			"content-type": "application/grpc",
-			te: "trailers",
-			...endpoint.token ? { authorization: `Bearer ${endpoint.token}` } : {}
-		});
-		const chunks = [];
-		let status;
-		let message;
-		let timedOut = false;
-		const record = (headers) => {
-			if (headers["grpc-status"] !== void 0) status = String(headers["grpc-status"]);
-			if (headers["grpc-message"] !== void 0) message = String(headers["grpc-message"]);
-		};
-		request.setTimeout(timeoutMs, () => {
-			timedOut = true;
-			request.close();
-		});
-		request.on("response", record);
-		request.on("trailers", record);
-		request.on("data", (chunk) => chunks.push(chunk));
-		request.on("error", (error) => {
-			const text = `${method} failed on ${serial}: ${error.message}`;
-			reject(timedOut ? timeoutError(text) : new Error(text));
-		});
-		request.on("close", () => {
-			if (status === "0") return resolve(Buffer.concat(chunks));
-			const text = `${method} failed on ${serial}: ${message ?? `status ${status ?? "missing"}`}`;
-			reject(timedOut ? timeoutError(text) : new Error(text));
-		});
-		request.end(requestBody);
-	});
-}
-const POSTURE_MODEL = grpcMessage([8, 16]);
-/**
-* The postures `input.posture` accepts for an owned device: the two panels of an iPhone Duo, and the hinge
-* positions of an emulator whose physical model has a posture.
-*/
-async function devicePostures(device, env, timeoutMs) {
-	if (device.platform === "ios") return device.foldable ? ["folded", "unfolded"] : [];
-	const endpoint = emulatorEndpoint(env, device.serial);
-	if (!endpoint) return [];
-	const session = grpcSession(endpoint);
-	try {
-		return hasHinge(await grpcCall(session, endpoint, device.serial, "getPhysicalModel", POSTURE_MODEL, timeoutMs)) ? [
-			"folded",
-			"half-open",
-			"unfolded"
-		] : [];
-	} catch {
-		return [];
-	} finally {
-		session.close();
-	}
-}
-function emulatorCapturer(serial, env, limits) {
-	let session = null;
-	let tmp = null;
-	const running = /* @__PURE__ */ new Set();
-	let hinged = null;
-	const call = (endpoint, method, requestBody) => {
-		if (!session || session.closed || session.destroyed) session = grpcSession(endpoint);
-		return grpcCall(session, endpoint, serial, method, requestBody, limits.toolTimeoutMs);
-	};
-	return {
-		capture: async () => {
-			const endpoint = emulatorEndpoint(env, serial);
-			if (!endpoint) throw new Error(`${serial} has no gRPC endpoint. Frames appear after Stim next boots this emulator.`);
-			hinged ??= await call(endpoint, "getPhysicalModel", POSTURE_MODEL).then(hasHinge).catch(() => false);
-			const { png, folded } = screenshotReply(await call(endpoint, "getScreenshot", grpcMessage([
-				24,
-				...varint(MAX_EDGE),
-				32,
-				...varint(MAX_EDGE)
-			])));
-			return {
-				raw: png,
-				...hinged ? { posture: folded ? "folded" : "unfolded" } : {},
-				jpeg: async () => {
-					tmp ??= mkdtempSync(join(serverDir(), "frames-"));
-					const input = join(tmp, "frame.png");
-					const output = join(tmp, "frame.jpg");
-					writeFileSync(input, png);
-					await runTool("sips", [
-						...[
-							"-s",
-							"format",
-							"jpeg",
-							"-s",
-							"formatOptions",
-							String(JPEG_QUALITY)
-						],
-						input,
-						"--out",
-						output
-					], env, running, limits.toolTimeoutMs);
-					return readFileSync(output);
-				}
-			};
-		},
-		close: () => {
-			session?.close();
-			return stopTools(running, tmp);
-		}
-	};
-}
-var Limiter = class {
-	active = 0;
-	waiting = [];
-	max;
-	constructor(max) {
-		this.max = max;
-	}
-	async run(task) {
-		if (this.active >= this.max) await new Promise((resolve) => this.waiting.push(resolve));
-		else this.active++;
-		try {
-			return await task();
-		} finally {
-			const next = this.waiting.shift();
-			if (next) next();
-			else this.active--;
-		}
-	}
-};
-var FrameSource = class {
-	listeners = /* @__PURE__ */ new Set();
-	last = null;
-	lastHash = null;
-	interval = MIN_INTERVAL_MS;
-	timer = null;
-	stopped = false;
-	delayed = false;
-	consecutiveFailures = 0;
-	capturer;
-	limiter;
-	limits;
-	ended;
-	constructor(capturer, limiter, limits, ended) {
-		this.capturer = capturer;
-		this.limiter = limiter;
-		this.limits = limits;
-		this.ended = ended;
-		this.tick();
-	}
-	add(listener) {
-		this.listeners.add(listener);
-		if (this.last) listener.frame(this.last);
-		if (this.delayed) listener.delayed(true);
-		return () => {
-			if (this.listeners.delete(listener) && this.listeners.size === 0) this.stop();
-		};
-	}
-	stop() {
-		if (this.stopped) return Promise.resolve();
-		this.stopped = true;
-		if (this.timer) clearTimeout(this.timer);
-		this.listeners.clear();
-		this.ended();
-		return this.capturer.close();
-	}
-	setDelayed(delayed) {
-		if (this.delayed === delayed) return;
-		this.delayed = delayed;
-		for (const listener of this.listeners) listener.delayed(delayed);
-	}
-	async tick() {
-		this.timer = null;
-		let took = 0;
-		try {
-			const changed = await this.limiter.run(async () => {
-				if (this.stopped) return false;
-				const started = Date.now();
-				const capture = await this.capturer.capture();
-				const hash = createHash("sha256").update(capture.raw).digest("hex");
-				took = Date.now() - started;
-				if (hash === this.lastHash || this.stopped) return false;
-				const jpeg = await capture.jpeg();
-				const size = jpegSize(jpeg);
-				if (!size) throw new Error("The screenshot is not a JPEG image.");
-				this.lastHash = hash;
-				this.last = {
-					...size,
-					capturedAt: new Date(started).toISOString(),
-					data: jpeg.toString("base64"),
-					...capture.posture ? { posture: capture.posture } : {}
-				};
-				took = Date.now() - started;
-				return true;
-			});
-			if (this.stopped) return;
-			this.consecutiveFailures = 0;
-			this.setDelayed(took > this.limits.slowCaptureMs);
-			if (changed) for (const listener of this.listeners) listener.frame(this.last);
-			this.interval = changed ? MIN_INTERVAL_MS : Math.min(this.interval * 2, MAX_INTERVAL_MS);
-			this.timer = setTimeout(() => void this.tick(), Math.max(this.interval - took, took));
-		} catch (error) {
-			if (this.stopped) return;
-			if (isTransient(error) && this.consecutiveFailures + 1 < this.limits.maxConsecutiveFailures) {
-				this.consecutiveFailures++;
-				this.setDelayed(true);
-				this.timer = setTimeout(() => void this.tick(), this.limits.failureBackoffMs);
-				return;
-			}
-			const listeners = [...this.listeners];
-			this.stop();
-			for (const listener of listeners) listener.failed(error.message);
-		}
-	}
-};
-/**
-* One capture per device, shared by its subscribers. A `stim-frames` helper stops `lingerMs` after the last of
-* them leaves, so a client that takes one frame at a time reuses it; a screenshot loop stops with the last of
-* them. With the `stim-frames`
-* helper, a device streams frames as its screen changes, at the rate its subscribers ask for; an iPhone Duo
-* streams its lit panel, which is its posture. Without the helper, and while it is still being built, a
-* screenshot loop sends a frame only when the screen changed: up to 5 times a second while it changes, backing
-* off to once a second while it does not, spending at most half of its time capturing, with at most two
-* captures at once across all devices. A helper that fails before its first frame gives way to the screenshot
-* loop.
-*/
-var FramePool = class {
-	sources = /* @__PURE__ */ new Map();
-	limiter = new Limiter(MAX_CAPTURES);
-	litPanels = /* @__PURE__ */ new Map();
-	env;
-	limits;
-	helper;
-	constructor(env, limits = DEFAULT_FRAME_LIMITS, helper = () => null) {
-		this.env = env;
-		this.limits = limits;
-		this.helper = helper;
-	}
-	subscribe(device, listener, hint = DEFAULT_FRAME_HINT) {
-		const helper = this.helper();
-		if (helper === null) return this.screenshots(device).add(listener);
-		let streamed = false;
-		let cancelled = false;
-		const { video } = listener;
-		let detach = this.stream(helper, device).add({
-			frame: (frame) => {
-				streamed = true;
-				listener.frame(frame);
-			},
-			...video ? { video: (unit) => {
-				streamed = true;
-				video(unit);
-			} } : {},
-			delayed: listener.delayed,
-			failed: (message) => {
-				if (streamed || cancelled) return listener.failed(message);
-				console.error(`stim-server: ${message} Falling back to screenshots.`);
-				detach = this.screenshots(device).add(listener);
-			}
-		}, hint);
-		return () => {
-			cancelled = true;
-			detach();
-		};
-	}
-	/** The posture of an iPhone Duo as its last frame showed it; null before a frame and for other devices. */
-	litPosture(device) {
-		const lit = device.platform === "ios" && device.foldable ? this.litPanels.get(device.udid) : void 0;
-		return lit ? POSTURES[lit] : null;
-	}
-	/** Records the panel a finished fold lit, so a request before the next frame sees the new posture. */
-	folded(udid, posture) {
-		this.litPanels.set(udid, posture === "folded" ? "primary" : "primary-1");
-	}
-	/** Makes the next video frame of `device` a keyframe, for a subscriber whose decoder lost its state. */
-	keyframe(device) {
-		this.helperSource(device)?.keyframe();
-	}
-	/** A subscriber of `device` is behind; called until its socket drains, it lowers the shared bitrate. */
-	congested(device) {
-		this.helperSource(device)?.congested();
-	}
-	helperSource(device) {
-		const source = this.sources.get(`helper:${deviceKey(device)}`);
-		return source instanceof HelperSource ? source : null;
-	}
-	/**
-	* Keeps the device's helper running to send it input, or returns null without a helper. `failed` runs when
-	* the helper exits.
-	*/
-	control(device, failed) {
-		const helper = this.helper();
-		if (helper === null) return null;
-		const source = this.stream(helper, device);
-		return {
-			send: (command) => source.send(command),
-			keys: () => source.keyboard === true,
-			detach: source.add({
-				frame: () => {},
-				delayed: () => {},
-				failed
-			}, null)
-		};
-	}
-	stream(helper, device) {
-		const key = `helper:${deviceKey(device)}`;
-		const existing = this.sources.get(key);
-		if (existing instanceof HelperSource) return existing;
-		const lit = device.platform === "ios" && device.foldable ? (display) => {
-			const panel = DUO_PANELS[display];
-			if (!panel) return void 0;
-			this.litPanels.set(device.udid, panel);
-			return POSTURES[panel];
-		} : void 0;
-		const created = new HelperSource(helper, device, this.env, () => {
-			if (this.sources.get(key) === created) this.sources.delete(key);
-		}, this.limits.lingerMs, lit);
-		this.sources.set(key, created);
-		return created;
-	}
-	screenshots(device) {
-		const key = deviceKey(device);
-		const existing = this.sources.get(key);
-		if (existing instanceof FrameSource) return existing;
-		const created = new FrameSource(device.platform === "ios" ? simulatorCapturer(device, this.env, this.limits, this.litPanels) : emulatorCapturer(device.serial, this.env, this.limits), this.limiter, this.limits, () => {
-			if (this.sources.get(key) === created) this.sources.delete(key);
-		});
-		this.sources.set(key, created);
-		return created;
-	}
-	async close() {
-		await Promise.all([...this.sources.values()].map((source) => source.stop()));
-	}
-};
-//#endregion
-//#region src/control.ts
-const SLOT_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
-const TEXT = /^[\x20-\x7e\n\t\b]+$/;
-function parseControlBegin(params) {
-	if (!isJsonObject(params)) return {
-		code: "bad-request",
-		message: "params must be an object."
-	};
-	const { workspace, platform, slot, takeOver, ...rest } = params;
-	if (Object.keys(rest).length) return {
-		code: "bad-request",
-		message: `control.begin does not take ${Object.keys(rest).join(", ")}.`
-	};
-	if (typeof workspace !== "string") return {
-		code: "bad-request",
-		message: "params.workspace must be an environment path from a status payload."
-	};
-	if (platform !== "ios" && platform !== "android") return {
-		code: "bad-request",
-		message: "params.platform must be ios or android."
-	};
-	if (slot !== void 0 && (typeof slot !== "string" || !SLOT_NAME.test(slot))) return {
-		code: "bad-request",
-		message: "params.slot must be 1-64 letters, digits, underscores or hyphens."
-	};
-	if (takeOver !== void 0 && typeof takeOver !== "boolean") return {
-		code: "bad-request",
-		message: "params.takeOver must be true or false."
-	};
-	return { value: {
-		workspace,
-		platform,
-		...slot ? { slot } : {},
-		...takeOver ? { takeOver } : {}
-	} };
-}
-const IOS_BUTTONS = ["home", "lock"];
-function fraction(value) {
-	return typeof value === "number" && value >= 0 && value <= 1;
-}
-/** Validates an `input.*` request for one of the connection's sessions; returns its session id and command. */
-function parseInput(method, params, targetOf) {
-	if (!isJsonObject(params) || typeof params.session !== "string") return {
-		code: "bad-request",
-		message: `${method} needs params.session from control.begin.`
-	};
-	const target = targetOf(params.session);
-	if (!target) return {
-		code: "unknown-session",
-		message: `No control session ${params.session} on this connection.`
-	};
-	const { platform, postures } = target;
-	const session = params.session;
-	if (method === "input.rotate") {
-		const { direction } = params;
-		if (!ROTATE_DIRECTIONS.includes(direction)) return {
-			code: "bad-request",
-			message: "input.rotate needs direction left or right."
-		};
-		return { value: {
-			session,
-			command: {
-				input: "rotate",
-				direction
-			}
-		} };
-	}
-	if (method === "input.posture") {
-		const { posture } = params;
-		if (!postures.includes(posture)) return {
-			code: "bad-request",
-			message: `This device ${postures.length ? `takes these postures: ${postures.join(", ")}` : "has no hinge"}.`
-		};
-		return { value: {
-			session,
-			command: {
-				input: "posture",
-				posture
-			}
-		} };
-	}
-	if (method === "input.touch") {
-		const { phase, x, y, display = 0 } = params;
-		if (!TOUCH_PHASES.includes(phase) || !fraction(x) || !fraction(y)) return {
-			code: "bad-request",
-			message: "input.touch needs phase (down, move or up), and x and y from 0 to 1."
-		};
-		if (!Number.isInteger(display) || display < 0 || display > 3) return {
-			code: "bad-request",
-			message: "display must be a display index from 0 to 3."
-		};
-		if (platform === "android" && display !== 0) return {
-			code: "bad-request",
-			message: "An emulator takes input on its main display (0) only."
-		};
-		return { value: {
-			session,
-			command: {
-				input: "touch",
-				phase,
-				x,
-				y,
-				display
-			}
-		} };
-	}
-	if (method === "input.text") {
-		const { text } = params;
-		if (typeof text !== "string" || !text.length || text.length > 256 || !TEXT.test(text)) return {
-			code: "bad-request",
-			message: `input.text takes 1 to 256 printable ASCII characters, with \\n, \\t and \\b.`
-		};
-		return { value: {
-			session,
-			command: {
-				input: "text",
-				text
-			}
-		} };
-	}
-	const { button } = params;
-	const allowed = platform === "ios" ? IOS_BUTTONS : INPUT_BUTTONS;
-	if (!allowed.includes(button)) return {
-		code: "bad-request",
-		message: `An ${platform} device takes these buttons: ${allowed.join(", ")}.`
-	};
-	return { value: {
-		session,
-		command: {
-			input: "button",
-			button
-		}
-	} };
-}
-const ANDROID_KEYS = {
-	home: "KEYCODE_HOME",
-	back: "KEYCODE_BACK",
-	"app-switch": "KEYCODE_APP_SWITCH",
-	lock: "KEYCODE_POWER",
-	"\n": "KEYCODE_ENTER",
-	"	": "KEYCODE_TAB",
-	"\b": "KEYCODE_DEL"
-};
-/**
-* The `adb shell` argument lists that type `text` or press `button` on an emulator without a hardware keyboard
-* (`hw.keyboard=no`), which drops gRPC key events. `adb shell` joins its arguments into one device shell
-* command, so text goes single-quoted; `input text` reads `%s` as a space.
-*/
-function adbInputArgs(command) {
-	if (command.input === "button") return [[
-		"shell",
-		"input",
-		"keyevent",
-		ANDROID_KEYS[command.button]
-	]];
-	const calls = [];
-	for (const part of command.text.split(/([\n\t\b]+)/)) {
-		if (!part) continue;
-		if (/^[\n\t\b]+$/.test(part)) {
-			calls.push([
-				"shell",
-				"input",
-				"keyevent",
-				...Array.from(part, (key) => ANDROID_KEYS[key])
-			]);
-			continue;
-		}
-		calls.push([
-			"shell",
-			"input",
-			"text",
-			`'${part.replaceAll(" ", "%s").replaceAll("'", "'\\''")}'`
-		]);
-	}
-	return calls;
-}
-function adbPath(env) {
-	for (const sdk of [
-		env.ANDROID_HOME,
-		env.ANDROID_SDK_ROOT,
-		join(env.HOME ?? homedir(), "Library/Android/sdk")
-	]) if (sdk && existsSync(join(sdk, "platform-tools/adb"))) return join(sdk, "platform-tools/adb");
-	return "adb";
-}
-const ADB_TIMEOUT_MS = 1e4;
-const POSTURE_TIMEOUT_MS = 5e3;
-function runQuietly(env, file, args, label, timeoutMs) {
-	return new Promise((resolve, reject) => {
-		const child = spawn(file, args, {
-			env,
-			stdio: [
-				"ignore",
-				"ignore",
-				"pipe"
-			]
-		});
-		let stderr = "";
-		const finish = (code) => {
-			clearTimeout(timer);
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`${label} failed (code ${code}): ${stderr.trim()}`));
-		};
-		const timer = setTimeout(() => {
-			child.stderr.destroy();
-			if (child.exitCode !== null || child.signalCode !== null) return finish(child.exitCode);
-			terminate(child);
-			reject(/* @__PURE__ */ new Error(`${label} did not finish within ${timeoutMs / 1e3} s.`));
-		}, timeoutMs);
-		child.stderr.setEncoding("utf8");
-		child.stderr.on("data", (chunk) => stderr = (stderr + chunk).slice(-500));
-		child.on("error", (error) => {
-			clearTimeout(timer);
-			reject(/* @__PURE__ */ new Error(`${label} could not start (${error.message}).`));
-		});
-		child.on("close", finish);
-	});
-}
-function runAdb(env, serial, args) {
-	return runQuietly(env, adbPath(env), [
-		"-s",
-		serial,
-		...args
-	], `adb ${args.slice(0, 3).join(" ")}`, ADB_TIMEOUT_MS);
-}
-function activityOf(payload, target) {
-	const environment = payload.environments?.find((candidate) => candidate.path === target.workspace);
-	const slot = target.slot ?? "default";
-	const devices = slot === "default" ? environment : environment?.slots?.find((candidate) => candidate.slot === slot);
-	return target.platform === "ios" ? devices?.ios?.activity : devices?.android?.activity;
-}
-function otherDriver(activity, ownLeases) {
-	if (activity?.state !== "driven" || !activity.driver) return null;
-	const { tool, since } = activity.driver;
-	if (tool === "stim device lock" && since && ownLeases.has(since)) return null;
-	return since ? `${tool} (since ${since})` : tool;
-}
-const STATUS_WAIT_MS = 6e4;
-/**
-* Control sessions across all connections: at most one per device. A session holds the device's `stim-frames`
-* helper for input and a `stim device lock` lease, renewed while it lasts and released when it ends if the
-* session took it.
-*/
-var ControlHub = class {
-	options;
-	sessions = /* @__PURE__ */ new Map();
-	byDevice = /* @__PURE__ */ new Map();
-	ownLeases = /* @__PURE__ */ new Set();
-	starting = /* @__PURE__ */ new Set();
-	folding = /* @__PURE__ */ new Set();
-	closing = false;
-	next = 1;
-	constructor(options) {
-		this.options = options;
-	}
-	targetOf(owner, session) {
-		const found = this.sessions.get(session);
-		return found && found.owner === owner && !found.ended ? {
-			platform: found.target.platform,
-			postures: found.postures
-		} : null;
-	}
-	/**
-	* `stillAllowed` is checked again after the status read and the lock, which can take seconds: the client may
-	* have disconnected or lost `control` meanwhile.
-	*/
-	async begin(owner, target, cwd, stillAllowed) {
-		const beganAt = Date.now();
-		if (this.closing) return {
-			code: "action-failed",
-			message: "stim-server is stopping."
-		};
-		const status = await this.status();
-		if ("code" in status) return status;
-		const device = ownedDevice(status, target, null);
-		if (typeof device === "string") return {
-			code: "action-failed",
-			message: device
-		};
-		const key = deviceKey(device);
-		if (this.starting.has(key)) return {
-			code: "device-busy",
-			message: "Another client is starting to control this device. Try again."
-		};
-		const earlier = this.byDevice.get(key);
-		const driver = earlier ? `${earlier.owner.device.name} through stim-server` : otherDriver(activityOf(status, target), this.ownLeases);
-		if (driver && !target.takeOver) return {
-			code: "device-busy",
-			message: `This device is driven by ${driver}. Take over to control it anyway.`
-		};
-		this.starting.add(key);
-		let lease;
-		let postures;
-		try {
-			[lease, postures] = await Promise.all([this.lock(device, target, cwd, beganAt), devicePostures(device, this.options.env, POSTURE_TIMEOUT_MS)]);
-		} finally {
-			this.starting.delete(key);
-		}
-		const granted = "code" in lease ? null : lease;
-		if (!granted && !target.takeOver) return lease;
-		const current = this.byDevice.get(key);
-		const refuse = (refusal) => {
-			if (granted?.mine && !current?.lease?.mine) this.unlock(target, cwd);
-			return refusal;
-		};
-		if (this.closing || !stillAllowed()) return refuse({
-			code: "forbidden",
-			message: "This device can no longer control devices."
-		});
-		if (current && current !== earlier && !target.takeOver) return refuse({
-			code: "device-busy",
-			message: `${current.owner.device.name} started controlling this device.`
-		});
-		let session;
-		const input = this.options.frames.control(device, (message) => queueMicrotask(() => void this.end(session, "failed", message)));
-		if (!input) return refuse({
-			code: "action-failed",
-			message: "Input needs the stim-frames helper, which this Mac has not built."
-		});
-		const inherited = granted !== null && current?.lease?.mine === true;
-		if (current) this.end(current, "taken-over", `${owner.device.name} took over this device.`, !inherited);
-		const id = `c${this.next++}`;
-		session = {
-			id,
-			owner,
-			device,
-			key,
-			target,
-			cwd,
-			lease: granted ? {
-				...granted,
-				mine: granted.mine || inherited
-			} : null,
-			input,
-			postures,
-			startedAt: Date.now(),
-			idle: setTimeout(() => void this.end(session, "idle", "No input for 5 minutes."), this.options.idleMs),
-			renew: setInterval(() => this.renew(session, beganAt), this.options.renewMs),
-			renewing: Promise.resolve(),
-			unwatch: () => {},
-			adb: Promise.resolve(),
-			ended: false
-		};
-		this.sessions.set(id, session);
-		this.byDevice.set(key, session);
-		session.unwatch = this.options.feeds.subscribe(this.options.statusFeed, {
-			item: (payload) => {
-				const resolved = ownedDevice(payload, target, key);
-				if (typeof resolved === "string" || deviceKey(resolved) !== key) {
-					const message = typeof resolved === "string" ? resolved : "The device changed.";
-					queueMicrotask(() => void this.end(session, "device-gone", message));
-				}
-			},
-			failed: () => {}
-		});
-		this.audit(owner, target, driver || current ? "control.take-over" : "control.begin", {
-			ok: true,
-			...driver || current ? { reason: `took over from ${driver ?? current.owner.device.name}` } : {}
-		});
-		return {
-			session: id,
-			platform: target.platform,
-			lease: session.lease ? {
-				grantedAt: session.lease.grantedAt,
-				expiresAt: session.lease.expiresAt
-			} : null,
-			postures
-		};
-	}
-	renew(session, beganAt) {
-		if (session.ended || !session.lease?.mine) return;
-		session.renewing = (async () => {
-			const renewed = await this.lock(session.device, session.target, session.cwd, beganAt);
-			if ("code" in renewed) console.error(`stim-server: could not renew the device lease: ${renewed.message}`);
-			else if (session.lease) session.lease.expiresAt = renewed.expiresAt;
-		})();
-	}
-	input(owner, id, command) {
-		const session = this.sessions.get(id);
-		if (!session || session.owner !== owner || session.ended) return Promise.resolve({
-			code: "unknown-session",
-			message: `No control session ${id} on this connection.`
-		});
-		session.idle.refresh();
-		if (command.input === "posture" && session.device.platform === "ios") return this.fold(session, session.device.udid, command.posture);
-		if (session.device.platform === "ios" || command.input === "touch" || command.input === "rotate" || command.input === "posture" || session.input.keys()) {
-			session.input.send(command);
-			return Promise.resolve(null);
-		}
-		const serial = session.device.serial;
-		const previous = session.adb;
-		const run = (async () => {
-			await previous;
-			try {
-				for (const args of adbInputArgs(command)) {
-					if (session.ended) return null;
-					await runAdb(this.options.env, serial, args);
-				}
-				return null;
-			} catch (cause) {
-				return {
-					code: "action-failed",
-					message: cause.message
-				};
-			}
-		})();
-		session.adb = run.then(() => void 0);
-		return run;
-	}
-	/**
-	* `sim-fold` sweeps the hinge to the other posture, so it runs only when the Duo's last frame shows the
-	* other one.
-	*/
-	async fold(session, udid, posture) {
-		if (this.folding.has(udid)) return {
-			code: "device-busy",
-			message: "The device is still folding."
-		};
-		const current = this.options.frames.litPosture(session.device);
-		if (!current) return {
-			code: "action-failed",
-			message: "Subscribe to frames of this device to learn its posture first."
-		};
-		if (current === posture) return null;
-		this.folding.add(udid);
-		try {
-			const helper = await this.options.foldHelper();
-			if (session.ended) return null;
-			await runQuietly(this.options.env, "xcrun", [
-				"simctl",
-				"spawn",
-				udid,
-				helper
-			], "sim-fold", this.options.foldTimeoutMs);
-			this.options.frames.folded(udid, posture === "folded" ? "folded" : "unfolded");
-			return null;
-		} catch (cause) {
-			return {
-				code: "action-failed",
-				message: cause.message
-			};
-		} finally {
-			this.folding.delete(udid);
-		}
-	}
-	endById(owner, id) {
-		const session = this.sessions.get(id);
-		if (!session || session.owner !== owner) return false;
-		this.end(session, null, "The client ended the session.");
-		return true;
-	}
-	endFor(owner, reason, message) {
-		for (const session of this.sessions.values()) if (session.owner === owner) this.end(session, reason, message);
-	}
-	async close() {
-		this.closing = true;
-		const releases = [...this.sessions.values()].map((session) => this.end(session, null, "stim-server stopped."));
-		await Promise.all(releases);
-	}
-	end(session, reason, message, release = true) {
-		if (session.ended) return Promise.resolve();
-		session.ended = true;
-		clearTimeout(session.idle);
-		clearInterval(session.renew);
-		session.unwatch();
-		session.input.detach();
-		this.sessions.delete(session.id);
-		if (this.byDevice.get(session.key) === session) this.byDevice.delete(session.key);
-		if (reason) session.owner.send({
-			event: "control-ended",
-			session: session.id,
-			reason,
-			message
-		});
-		this.audit(session.owner, session.target, "control.end", {
-			ok: true,
-			durationMs: Date.now() - session.startedAt,
-			reason: `${reason ?? "ended"}: ${message}`
-		});
-		if (!release || !session.lease?.mine) return Promise.resolve();
-		return session.renewing.then(() => this.unlock(session.target, session.cwd));
-	}
-	status() {
-		return new Promise((resolve) => {
-			let settled = false;
-			let unsubscribe = null;
-			const finish = (value) => {
-				if (settled) return;
-				settled = true;
-				clearTimeout(timer);
-				unsubscribe?.();
-				resolve(value);
-			};
-			const timer = setTimeout(() => finish({
-				code: "status-failed",
-				message: "stim status did not report the device in time."
-			}), STATUS_WAIT_MS);
-			unsubscribe = this.options.feeds.subscribe(this.options.statusFeed, {
-				item: (payload) => finish(payload),
-				failed: (message) => finish({
-					code: "status-failed",
-					message
-				})
-			});
-			if (settled) unsubscribe();
-		});
-	}
-	async lock(device, target, cwd, beganAt) {
-		const id = device.platform === "ios" ? device.udid : device.serial;
-		const slot = target.slot && target.slot !== "default" ? ["--slot", target.slot] : [];
-		const args = [
-			"device",
-			"lock",
-			target.platform,
-			id,
-			"--for",
-			this.options.leaseFor,
-			"--wait",
-			"0",
-			"--json",
-			...slot
-		];
-		const printed = actionOutcome(await runStim(this.options.stimCli, this.options.env, args, cwd, this.options.lockLimits).outcome);
-		if (!printed.ok) return {
-			code: printed.error.message.startsWith("STIM_DEVICE_BUSY") ? "device-busy" : "action-failed",
-			message: `stim device lock: ${printed.error.message}`
-		};
-		const grantedAt = typeof printed.output.grantedAt === "string" ? printed.output.grantedAt : null;
-		const expiresAt = typeof printed.output.expiresAt === "string" ? printed.output.expiresAt : "";
-		const mine = grantedAt !== null && Date.parse(grantedAt) >= beganAt - 1e3;
-		if (mine) this.ownLeases.add(grantedAt);
-		return {
-			grantedAt,
-			expiresAt,
-			mine
-		};
-	}
-	async unlock(target, cwd) {
-		const slot = target.slot && target.slot !== "default" ? ["--slot", target.slot] : [];
-		const outcome = await runStim(this.options.stimCli, this.options.env, [
-			"device",
-			"unlock",
-			target.platform,
-			"--json",
-			...slot
-		], cwd, this.options.lockLimits).outcome;
-		if (!outcome.ok) console.error(`stim-server: could not release the device lease: ${outcome.message}`);
-	}
-	audit(owner, target, action, outcome) {
-		this.options.audit({
-			at: (/* @__PURE__ */ new Date()).toISOString(),
-			device: {
-				id: owner.device.id,
-				name: owner.device.name
-			},
-			action,
-			workspace: target.workspace,
-			platform: target.platform,
-			...outcome
-		});
-	}
-};
-//#endregion
-//#region src/feed.ts
-var Feed = class {
-	listeners = /* @__PURE__ */ new Set();
-	kept = [];
-	child;
-	ended;
-	constructor(spec, stimCli, env, ended) {
-		this.ended = ended;
-		const child = spawn(process.execPath, [stimCli, ...spec.args], {
-			cwd: spec.cwd,
-			env,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			]
-		});
-		this.child = child;
-		let stderr = "";
-		child.stderr?.setEncoding("utf8");
-		child.stderr?.on("data", (chunk) => {
-			stderr = (stderr + chunk).slice(-2e3);
-		});
-		createInterface({ input: child.stdout }).on("line", (line) => {
-			if (this.child !== child) return;
-			let value;
-			try {
-				value = JSON.parse(line);
-			} catch {
-				return;
-			}
-			if (!isJsonObject(value)) return;
-			this.kept.push({
-				value,
-				text: line
-			});
-			if (this.kept.length > spec.keep) this.kept.shift();
-			for (const listener of this.listeners) listener.item(value, line);
-		});
-		const exited = (reason) => {
-			if (this.child !== child) return;
-			this.child = null;
-			this.ended();
-			const message = `${spec.label} ${reason}${stderr.trim() ? `: ${stderr.trim()}` : ""}`;
-			const listeners = [...this.listeners];
-			this.listeners.clear();
-			for (const listener of listeners) listener.failed(message);
-		};
-		child.on("error", (error) => exited(`could not start (${error.message})`));
-		child.on("close", (code, signal) => exited(`exited (${signal ?? `code ${code}`})`));
-	}
-	add(listener) {
-		this.listeners.add(listener);
-		for (const { value, text } of this.kept) listener.item(value, text);
-		return () => {
-			if (this.listeners.delete(listener) && this.listeners.size === 0) this.stop();
-		};
-	}
-	stop() {
-		const child = this.child;
-		if (!child) return Promise.resolve();
-		this.child = null;
-		this.listeners.clear();
-		this.ended();
-		return terminate(child);
-	}
-};
-var FeedPool = class {
-	feeds = /* @__PURE__ */ new Map();
-	stimCli;
-	env;
-	constructor(stimCli, env) {
-		this.stimCli = stimCli;
-		this.env = env;
-	}
-	subscribe(spec, listener) {
-		const key = JSON.stringify([spec.cwd, spec.args]);
-		let feed = this.feeds.get(key);
-		if (!feed) {
-			const created = new Feed(spec, this.stimCli, this.env, () => {
-				if (this.feeds.get(key) === created) this.feeds.delete(key);
-			});
-			this.feeds.set(key, created);
-			feed = created;
-		}
-		return feed.add(listener);
-	}
-	async close() {
-		await Promise.all([...this.feeds.values()].map((feed) => feed.stop()));
-	}
-};
-//#endregion
-//#region src/logs.ts
-function parseLogFilter(params) {
-	if (!isJsonObject(params) || typeof params.workspace !== "string") return { error: "params.workspace is required." };
-	const { sources, level, slot, grep, errors, tail } = params;
-	if (sources !== void 0 && (!Array.isArray(sources) || sources.length === 0 || !sources.every((source) => LOG_SOURCES.includes(source)))) return { error: `sources must be a non-empty list of ${LOG_SOURCES.join(", ")}.` };
-	if (level !== void 0 && !LOG_LEVELS.includes(level)) return { error: `level must be one of ${LOG_LEVELS.join(", ")}.` };
-	if (slot !== void 0 && (typeof slot !== "string" || !SLOT_NAME.test(slot))) return { error: "slot must be 1-64 letters, digits, underscores or hyphens." };
-	if (grep !== void 0 && (typeof grep !== "string" || grep.includes("\0") || compileGrep(grep).error)) return { error: "grep must be a valid regular expression without NUL characters." };
-	if (errors !== void 0 && typeof errors !== "boolean") return { error: "errors must be true or false." };
-	if (tail !== void 0 && (!Number.isInteger(tail) || tail < 1 || tail > 5e3)) return { error: `tail must be an integer from 1 to ${MAX_LOG_TAIL}.` };
-	return { filter: {
-		workspace: params.workspace,
-		...sources ? { sources } : {},
-		...level && level !== "debug" ? { level } : {},
-		...slot ? { slot } : {},
-		...grep ? { grep } : {},
-		...errors ? { errors } : {},
-		tail: tail ?? 5e3
-	} };
-}
-function logArgs(filter, follow) {
-	const args = [
-		"logs",
-		"--json",
-		...follow ? ["--follow"] : [],
-		`--tail=${filter.tail ?? 5e3}`
-	];
-	if (filter.sources) args.push("--source", ...LOG_SOURCES.filter((source) => filter.sources.includes(source)));
-	if (filter.slot) args.push(`--slot=${filter.slot}`);
-	if (filter.level) args.push(`--level=${filter.level}`);
-	if (filter.grep) args.push(`--grep=${filter.grep}`);
-	if (filter.errors) args.push("--errors");
-	return args;
-}
-const BATCH_MS = 100;
-const MAX_BATCH = 500;
-var LogBatcher = class {
-	pending = [];
-	timer = null;
-	stopped = false;
-	sink;
-	limits;
-	constructor(sink, limits) {
-		this.sink = sink;
-		this.limits = limits;
-	}
-	push(record) {
-		if (this.stopped) return;
-		this.pending.push(record);
-		if (this.pending.length > this.limits.maxPendingRecords) {
-			this.stop();
-			queueMicrotask(this.sink.overflow);
-			return;
-		}
-		this.timer ??= setTimeout(() => this.flush(false), BATCH_MS);
-	}
-	flush(force) {
-		if (this.timer) clearTimeout(this.timer);
-		this.timer = null;
-		while (this.pending.length) {
-			if (!force && this.sink.bufferedBytes() >= this.limits.maxBufferedBytes) break;
-			this.sink.send(this.pending.splice(0, MAX_BATCH));
-		}
-		if (this.pending.length && !this.stopped) this.timer = setTimeout(() => this.flush(false), BATCH_MS);
-	}
-	stop() {
-		this.stopped = true;
-		if (this.timer) clearTimeout(this.timer);
-		this.timer = null;
-		this.pending = [];
-	}
-};
-//#endregion
-//#region src/machine.ts
-function stimDiskLocations() {
-	let workspaces = [];
-	try {
-		workspaces = Object.keys(loadConfig()?.projects ?? {});
-	} catch {}
-	return [
-		...workspaces.map((path) => ({
-			label: "Workspaces",
-			path
-		})),
-		{
-			label: "Stim home",
-			path: configDir()
-		},
-		...process.platform === "darwin" ? [{
-			label: "Simulators",
-			path: join(homedir(), "Library", "Developer", "CoreSimulator")
-		}] : []
-	];
-}
-function existingAncestor(path) {
-	let current = path;
-	while (!existsSync(current) && dirname(current) !== current) current = dirname(current);
-	return current;
-}
-function mountOf(path) {
-	return /^\/Volumes\/[^/]+/.exec(path)?.[0] ?? "/";
-}
-function readVolumes(locations) {
-	const byDevice = /* @__PURE__ */ new Map();
-	for (const { label, path } of locations) try {
-		const existing = existingAncestor(path);
-		const device = statSync(existing).dev;
-		const known = byDevice.get(device);
-		if (known) {
-			if (!known.holds.includes(label)) known.holds.push(label);
-			continue;
-		}
-		const fs = statfsSync(existing);
-		byDevice.set(device, {
-			mount: mountOf(existing),
-			holds: [label],
-			freeBytes: fs.bavail * fs.bsize,
-			totalBytes: fs.blocks * fs.bsize
-		});
-	} catch {}
-	return [...byDevice.values()];
-}
-function readMemoryPressure() {
-	if (process.platform !== "darwin") return Promise.resolve(null);
-	return new Promise((resolve) => {
-		execFile("/usr/sbin/sysctl", ["-n", "kern.memorystatus_vm_pressure_level"], { timeout: 2e3 }, (error, stdout) => {
-			const level = error ? "" : stdout.trim();
-			resolve(level === "1" ? "normal" : level === "2" ? "warning" : level === "4" ? "critical" : null);
-		});
-	});
-}
-/**
-* Activity Monitor's "Memory Used" from `vm_stat` output: app memory (anonymous minus purgeable pages),
-* wired, and compressed pages, times the page size its header names. Null when a count is missing.
-*/
-function parseVmStatUsedBytes(output) {
-	const pageSize = /page size of (\d+) bytes/.exec(output)?.[1];
-	const count = (label) => {
-		const value = new RegExp(`^${label}:\\s+(\\d+)\\.`, "m").exec(output)?.[1];
-		return value === void 0 ? null : Number(value);
-	};
-	const anonymous = count("Anonymous pages");
-	const purgeable = count("Pages purgeable");
-	const wired = count("Pages wired down");
-	const compressed = count("Pages occupied by compressor");
-	if (!pageSize || anonymous === null || purgeable === null || wired === null || compressed === null) return null;
-	return (Math.max(0, anonymous - purgeable) + wired + compressed) * Number(pageSize);
-}
-function readMemoryUsed() {
-	if (process.platform !== "darwin") return Promise.resolve(null);
-	return new Promise((resolve) => {
-		execFile("/usr/bin/vm_stat", { timeout: 2e3 }, (error, stdout) => {
-			resolve(error ? null : parseVmStatUsedBytes(stdout));
-		});
-	});
-}
-function cpuTicks(list) {
-	let idle = 0;
-	let total = 0;
-	for (const cpu of list) {
-		idle += cpu.times.idle;
-		total += cpu.times.user + cpu.times.nice + cpu.times.sys + cpu.times.irq + cpu.times.idle;
-	}
-	return {
-		idle,
-		total
-	};
-}
-/** The busy fraction (0..1) between two `os.cpus()` tick totals. Null when the totals did not advance. */
-function cpuUsageFraction(previous, current) {
-	const totalDelta = current.total - previous.total;
-	if (totalDelta <= 0) return null;
-	const idleDelta = current.idle - previous.idle;
-	return Math.min(1, Math.max(0, 1 - idleDelta / totalDelta));
-}
-let previousCpuTicks = null;
-function readCpuUsage() {
-	const current = cpuTicks(cpus());
-	const usage = previousCpuTicks ? cpuUsageFraction(previousCpuTicks, current) : null;
-	previousCpuTicks = current;
-	return {
-		usage,
-		cores: availableParallelism()
-	};
-}
-/** The volumes `machine.get` reports, without its CPU and memory readings. */
-function readDiskVolumes() {
-	return readVolumes(stimDiskLocations());
-}
-async function readMachineUsage() {
-	const [avg1 = 0, avg5 = 0, avg15 = 0] = loadavg();
-	const [pressure, usedBytes] = await Promise.all([readMemoryPressure(), readMemoryUsed()]);
-	return {
-		volumes: readVolumes(stimDiskLocations()),
-		memory: {
-			totalBytes: totalmem(),
-			usedBytes,
-			pressure
-		},
-		load: {
-			avg1,
-			avg5,
-			avg15,
-			cpus: availableParallelism()
-		},
-		cpu: readCpuUsage(),
-		sampledAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-}
-const PRESSURE_LEVEL = {
-	normal: 0,
-	warning: 1,
-	critical: 2
-};
-const HISTORY_INTERVAL_MS = 5e3;
-const HISTORY_CAPACITY = 720;
-var UsageSampler = class {
-	samples = [];
-	previousTicks = null;
-	timer = null;
-	intervalMs;
-	capacity;
-	constructor(intervalMs = HISTORY_INTERVAL_MS, capacity = HISTORY_CAPACITY) {
-		this.intervalMs = intervalMs;
-		this.capacity = capacity;
-	}
-	start() {
-		if (this.timer) return;
-		this.previousTicks = cpuTicks(cpus());
-		this.timer = setInterval(() => void this.sample(), this.intervalMs);
-	}
-	stop() {
-		if (this.timer) clearInterval(this.timer);
-		this.timer = null;
-		this.previousTicks = null;
-	}
-	record(sample) {
-		this.samples.push(sample);
-		if (this.samples.length > this.capacity) this.samples.splice(0, this.samples.length - this.capacity);
-	}
-	history(sinceMs) {
-		const samples = sinceMs === void 0 ? [...this.samples] : this.samples.filter((s) => s.at > sinceMs);
-		return {
-			intervalMs: this.intervalMs,
-			samples
-		};
-	}
-	async sample() {
-		const at = Date.now();
-		const ticks = cpuTicks(cpus());
-		const cpu = this.previousTicks ? cpuUsageFraction(this.previousTicks, ticks) : null;
-		this.previousTicks = ticks;
-		const [pressure, memoryUsedBytes] = await Promise.all([readMemoryPressure(), readMemoryUsed()]);
-		let diskFreeBytes = null;
-		try {
-			const fs = statfsSync("/");
-			diskFreeBytes = fs.bavail * fs.bsize;
-		} catch {}
-		if (!this.timer) return;
-		this.record({
-			at,
-			cpu,
-			memoryUsedBytes,
-			memoryPressure: pressure === null ? null : PRESSURE_LEVEL[pressure],
-			diskFreeBytes
-		});
-	}
-};
-//#endregion
-//#region src/attention.ts
-const OVERRUN_FACTOR = 2;
-const RECENT_FAILURE_MS = 864e5;
-const DISK_CRITICAL_BYTES = 5e9;
-const platformName = (platform) => platform === "ios" ? "iOS" : "Android";
-const basename$1 = (path) => path.split("/").findLast(Boolean) ?? path;
-function clockDuration(ms) {
-	const seconds = Math.max(0, Math.floor(ms / 1e3));
-	return `${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, "0")}`;
-}
-function formatBytes(bytes) {
-	if (bytes >= 0xe8d4a51000) return `${(bytes / 0xe8d4a51000).toFixed(1)} TB`;
-	const gb = bytes / 1e9;
-	return gb >= 100 ? `${Math.round(gb)} GB` : `${gb.toFixed(1)} GB`;
-}
-function worktreeRoot(path) {
-	const parts = path.split("/");
-	for (let i = parts.length - 2; i > 0; i--) {
-		if (parts[i] === ".worktrees") return parts.slice(0, i).join("/");
-		if (parts[i] === "worktrees" && parts[i - 1] === ".claude") return parts.slice(0, i - 1).join("/");
-	}
-	return null;
-}
-function markedCheckout(path) {
-	const parts = path.split("/");
-	for (let i = parts.length - 2; i > 0; i--) if (parts[i] === ".worktrees" || parts[i] === "worktrees" && parts[i - 1] === ".claude") return parts.slice(0, i + 2).join("/");
-	return null;
-}
-function repositoryRoots(payload) {
-	const roots = /* @__PURE__ */ new Set();
-	for (const { path, worktree } of payload.environments) roots.add(worktreeRoot(path) ?? worktree?.repository ?? path);
-	for (const { path, repository } of payload.unprovisionedWorktrees ?? []) {
-		const root = worktreeRoot(path) ?? repository;
-		if (root) roots.add(root);
-	}
-	return [...roots];
-}
-function workspaceTitle(env, roots) {
-	if (env.worktree?.branch) return env.worktree.branch;
-	const checkout = env.worktree?.path ?? markedCheckout(env.path);
-	if (checkout) return basename$1(checkout);
-	const root = worktreeRoot(env.path) ?? env.worktree?.repository ?? roots.filter((r) => env.path === r || env.path.startsWith(`${r}/`)).reduce((best, r) => best === null || r.length < best.length ? r : best, null) ?? env.path;
-	return basename$1(root);
-}
-function devicesOf(env) {
-	const out = [];
-	const add = (slot, ios, android) => {
-		if (ios) out.push({
-			platform: "ios",
-			slot,
-			model: /\(([^()]*(?:\([^()]*\)[^()]*)*)\)\s*$/.exec(ios.name ?? "")?.[1] ?? "iOS Simulator",
-			running: ios.state === "Booted",
-			driven: ios.activity?.state === "driven",
-			appStopped: ios.app?.state === "stopped"
-		});
-		if (android) out.push({
-			platform: "android",
-			slot,
-			model: android.physical ? "Android device" : "Android Emulator",
-			running: android.state === "detected",
-			driven: android.activity?.state === "driven",
-			appStopped: android.app?.state === "stopped"
-		});
-	};
-	add("default", env.ios, env.android);
-	for (const slot of env.slots ?? []) add(slot.slot, slot.ios, slot.android);
-	return out;
-}
-function runningBuild(env, device) {
-	const build = env.build;
-	if (!build || build.state !== "running") return null;
-	if (device && (build.platform !== device.platform || build.slot !== device.slot)) return null;
-	return build;
-}
-const isActive = (env) => env.live || env.build?.state === "running" || (env.remoteDevices?.length ?? 0) > 0;
-function workspaceCandidates(env, title, now) {
-	const items = [];
-	const active = isActive(env);
-	const devices = devicesOf(env);
-	const driven = devices.some((device) => device.driven);
-	const add = (id, event, occurrence, reason, extra) => items.push({
-		key: `${env.path}\n${id}`,
-		event,
-		occurrence,
-		title,
-		reason,
-		target: {
-			kind: "workspace",
-			path: env.path
-		},
-		driven,
-		...extra
-	});
-	for (const platform of ["ios", "android"]) {
-		const last = env.lastBuilds?.[platform];
-		if (!last || last.status !== "failed" || runningBuild(env)?.platform === platform) continue;
-		const endedAt = last.finishedAt ?? last.startedAt;
-		if (!active && !(now - Date.parse(endedAt) < RECENT_FAILURE_MS)) continue;
-		const code = last.errorCode ? ` (${last.errorCode})` : "";
-		add(`build-${platform}`, "build-failed", endedAt, `${platformName(platform)} build failed${code}`, {});
-	}
-	const errors = env.logs?.errorsSinceMarker ?? 0;
-	if (active && errors > 0) add("logs", "log-errors", String(errors), `${errors === 1 ? "1 error" : `${errors} errors`} in the logs`, {
-		target: {
-			kind: "logs",
-			path: env.path
-		},
-		count: errors
-	});
-	const build = runningBuild(env);
-	const started = build ? Date.parse(build.startedAt) : NaN;
-	if (build?.expectedMs && Number.isFinite(started) && now - started > OVERRUN_FACTOR * build.expectedMs) add("overrun", "slow-build", build.startedAt, `${platformName(build.platform)} build at ${clockDuration(now - started)}, usually ~${clockDuration(build.expectedMs)}`, {});
-	if (env.live) for (const device of devices) {
-		if (!device.running || !device.appStopped || runningBuild(env, device)) continue;
-		add(`app-${device.platform}-${device.slot}`, "app-stopped", "", `App not running on ${device.model}`, {});
-	}
-	return items;
-}
-/**
-* The machine's disk item and each workspace's failed builds, log errors, build overrun and stopped apps, with
-* the phone strip's rules: an idle workspace reports only a build that failed in the last day.
-*/
-function attentionCandidates(status, volumes, name, now) {
-	const candidates = [];
-	const lowest = volumes?.reduce((min, v) => min === null ? v.freeBytes : Math.min(min, v.freeBytes), null);
-	if (lowest !== null && lowest !== void 0 && lowest < DISK_CRITICAL_BYTES) candidates.push({
-		key: "disk",
-		event: "disk",
-		occurrence: "",
-		title: name,
-		reason: `${formatBytes(lowest)} free, below Stim's floor`,
-		target: { kind: "machine" },
-		driven: null
-	});
-	const roots = repositoryRoots(status);
-	for (const env of status.environments) candidates.push(...workspaceCandidates(env, workspaceTitle(env, roots), now));
-	return candidates;
-}
-//#endregion
-//#region src/notify.ts
-/** How long an item must hold before it notifies: log errors settle, and an offline machine may reconnect. */
-const SETTLE_MS = {
-	"log-errors": 1e4,
-	offline: 6e4
-};
-/** Log errors that keep arriving still notify this long after the first one. */
-const MAX_SETTLE_MS = 6e4;
-const LOG_COOLDOWN_MS = 3e5;
-/** An item absent this long is forgotten, so a later one notifies again; a shorter gap is the same problem. */
-const FORGET_MS = 12e4;
-/**
-* The notifications `candidates` owe since `entries`, the state the previous call returned. Null `entries`
-* records every candidate without notifying, so what is already wrong at the first check stays quiet. An item
-* notifies once per occurrence. `awakeSince` restarts the settle time, for a checker that was not running.
-*/
-function diffAttention(entries, candidates, choice, now, awakeSince = 0) {
-	const next = {};
-	const notify = [];
-	let wakeAt = null;
-	for (const candidate of candidates) {
-		const prev = entries?.[candidate.key];
-		let entry = prev && prev.occurrence === candidate.occurrence ? {
-			...prev,
-			seenAt: now
-		} : {
-			occurrence: candidate.occurrence,
-			since: now,
-			heldSince: prev && !prev.done ? prev.heldSince : now,
-			seenAt: now,
-			notifiedAt: prev?.notifiedAt ?? null,
-			done: entries === null,
-			...prev?.count !== void 0 ? { count: prev.count } : {}
-		};
-		if (entries === null) entry = {
-			...entry,
-			count: candidate.count
-		};
-		next[candidate.key] = entry;
-		if (entry.done) continue;
-		if (!(choice.events.includes(candidate.event) && !(choice.agentOnly && candidate.driven === false))) {
-			next[candidate.key] = {
-				...entry,
-				done: true,
-				count: candidate.count
-			};
-			continue;
-		}
-		const settle = SETTLE_MS[candidate.event] ?? 0;
-		let dueAt = Math.max(Math.min(entry.since + settle, entry.heldSince + MAX_SETTLE_MS), awakeSince + settle);
-		if (candidate.event === "log-errors" && entry.notifiedAt !== null) dueAt = Math.max(dueAt, entry.notifiedAt + LOG_COOLDOWN_MS);
-		if (now < dueAt) {
-			wakeAt = wakeAt === null ? dueAt : Math.min(wakeAt, dueAt);
-			continue;
-		}
-		next[candidate.key] = {
-			...entry,
-			done: true,
-			notifiedAt: now,
-			count: candidate.count
-		};
-		notify.push(candidate.event === "log-errors" ? {
-			...candidate,
-			reason: newErrors(candidate, entry.count)
-		} : candidate);
-	}
-	for (const [key, entry] of Object.entries(entries ?? {})) if (!(key in next) && now - entry.seenAt < FORGET_MS) next[key] = entry;
-	return {
-		entries: next,
-		notify,
-		wakeAt
-	};
-}
-function newErrors(candidate, before) {
-	const count = candidate.count ?? 0;
-	const added = before !== void 0 && count > before ? count - before : count;
-	const noun = added === 1 ? "error" : "errors";
-	return added === count ? `${count} ${noun} in the logs` : `${added} new ${noun} in the logs`;
-}
-const DEFAULT_PUSH_LIMITS = {
-	tickMs: 3e4,
-	diskMs: 6e4,
-	receiptDelayMs: 9e5,
-	perHour: 20,
-	summarizeAbove: 3,
-	resubscribeMs: 3e4
-};
-/**
-* Pushes attention notifications to the devices that asked with `push.register`. While any device is
-* registered it keeps its own `stim status --watch --json` subscription and reads the disks every minute.
-*/
-var PushNotifier = class {
-	options;
-	limits;
-	now;
-	registered = /* @__PURE__ */ new Map();
-	unsubscribe = null;
-	status = null;
-	volumes = null;
-	timers = /* @__PURE__ */ new Set();
-	tick = null;
-	disk = null;
-	wake = null;
-	resubscribe = null;
-	closed = false;
-	constructor(options) {
-		this.options = options;
-		this.limits = {
-			...DEFAULT_PUSH_LIMITS,
-			...options.limits
-		};
-		this.now = options.now ?? Date.now;
-	}
-	/** Rereads the registrations; a device whose token is new starts from what is already wrong. */
-	refresh() {
-		if (this.closed) return;
-		const current = new Map(this.options.devices().flatMap((d) => d.push ? [[d.id, d.push]] : []));
-		for (const id of this.registered.keys()) if (!current.has(id)) this.registered.delete(id);
-		let added = false;
-		for (const [id, push] of current) {
-			const known = this.registered.get(id);
-			if (known && known.push.token === push.token) {
-				known.push = push;
-				continue;
-			}
-			this.registered.set(id, {
-				push,
-				entries: null,
-				bucket: {
-					tokens: this.limits.perHour,
-					at: this.now()
-				}
-			});
-			added = true;
-		}
-		if (this.registered.size > 0) this.watch();
-		else this.unwatch();
-		if (added) this.evaluate();
-	}
-	close() {
-		this.closed = true;
-		this.unwatch();
-		for (const timer of this.timers) clearTimeout(timer);
-		this.timers.clear();
-	}
-	watch() {
-		if (!this.disk) {
-			this.readDisk();
-			this.disk = setInterval(() => {
-				this.readDisk();
-				this.evaluate();
-			}, this.limits.diskMs);
-		}
-		if (!this.tick) this.tick = setInterval(() => this.evaluate(), this.limits.tickMs);
-		if (!this.unsubscribe && !this.resubscribe) this.subscribe();
-	}
-	unwatch() {
-		this.unsubscribe?.();
-		this.unsubscribe = null;
-		for (const timer of [this.tick, this.disk]) if (timer) clearInterval(timer);
-		for (const timer of [this.wake, this.resubscribe]) if (timer) clearTimeout(timer);
-		this.tick = this.disk = this.wake = this.resubscribe = null;
-		this.status = null;
-		this.volumes = null;
-	}
-	subscribe() {
-		this.unsubscribe = this.options.subscribeStatus({
-			item: (value) => {
-				this.status = value;
-				this.evaluate();
-			},
-			failed: (message) => {
-				console.error(`stim-server: push notifications paused: ${message}`);
-				this.unsubscribe = null;
-				this.status = null;
-				this.resubscribe = setTimeout(() => {
-					this.resubscribe = null;
-					if (this.registered.size > 0 && !this.closed) this.subscribe();
-				}, this.limits.resubscribeMs);
-			}
-		});
-	}
-	readDisk() {
-		try {
-			this.volumes = this.options.readVolumes();
-		} catch {
-			this.volumes = null;
-		}
-	}
-	evaluate() {
-		const status = this.status;
-		if (!status || this.closed) return;
-		const now = this.now();
-		const candidates = attentionCandidates(status, this.volumes, this.options.name, now);
-		const messages = [];
-		let wakeAt = null;
-		for (const device of this.registered.values()) {
-			const diff = diffAttention(device.entries, candidates, device.push, now);
-			device.entries = diff.entries;
-			if (diff.wakeAt !== null) wakeAt = wakeAt === null ? diff.wakeAt : Math.min(wakeAt, diff.wakeAt);
-			const due = diff.notify.length > this.limits.summarizeAbove ? [this.summary(device, diff.notify)] : diff.notify.map((c) => this.message(device.push, c));
-			for (const message of due) if (this.take(device, now)) messages.push(message);
-		}
-		if (this.wake) clearTimeout(this.wake);
-		this.wake = wakeAt === null ? null : setTimeout(() => this.evaluate(), Math.max(0, wakeAt - now));
-		if (messages.length > 0) this.send(messages);
-	}
-	take(device, now) {
-		const { bucket } = device;
-		bucket.tokens = Math.min(this.limits.perHour, bucket.tokens + (now - bucket.at) * this.limits.perHour / 36e5);
-		bucket.at = now;
-		if (bucket.tokens < 1) return false;
-		bucket.tokens -= 1;
-		return true;
-	}
-	message(push, candidate) {
-		const machine = candidate.target.kind === "machine";
-		return {
-			to: push.token,
-			title: candidate.title,
-			...machine ? {} : { subtitle: this.options.name },
-			body: candidate.reason,
-			sound: "default",
-			data: {
-				ref: push.ref,
-				target: candidate.target.kind,
-				...candidate.target.kind === "machine" ? {} : { path: candidate.target.path }
-			}
-		};
-	}
-	summary(device, candidates) {
-		return {
-			to: device.push.token,
-			title: this.options.name,
-			body: `${candidates.length} problems need attention`,
-			sound: "default",
-			data: {
-				ref: device.push.ref,
-				target: "home"
-			}
-		};
-	}
-	later(fn, ms) {
-		if (this.closed) return;
-		const timer = setTimeout(() => {
-			this.timers.delete(timer);
-			if (!this.closed) fn();
-		}, ms);
-		timer.unref();
-		this.timers.add(timer);
-	}
-	async post(path, body) {
-		const response = await fetch(`${this.options.endpoint}/${path}`, {
-			method: "POST",
-			headers: {
-				accept: "application/json",
-				"content-type": "application/json"
-			},
-			body: JSON.stringify(body),
-			signal: AbortSignal.timeout(3e4)
-		});
-		if (!response.ok) throw new Error(`HTTP ${response.status}`);
-		return (await response.json()).data;
-	}
-	async send(messages) {
-		let tickets;
-		try {
-			tickets = await this.post("send", messages);
-		} catch (cause) {
-			console.error(`stim-server: could not send ${messages.length} push notifications: ${cause.message}`);
-			return;
-		}
-		if (!Array.isArray(tickets) || this.closed) return;
-		const receipts = /* @__PURE__ */ new Map();
-		tickets.forEach((ticket, index) => {
-			const to = messages[index]?.to;
-			if (!to) return;
-			if (ticket?.status === "ok" && typeof ticket.id === "string") receipts.set(ticket.id, to);
-			else if (ticket?.details?.error === "DeviceNotRegistered") this.drop(to);
-			else if (ticket?.status === "error") console.error(`stim-server: Expo refused a push: ${String(ticket.message)}`);
-		});
-		if (receipts.size > 0) this.later(() => void this.checkReceipts(receipts), this.limits.receiptDelayMs);
-	}
-	drop(token) {
-		try {
-			this.options.dropToken(token);
-		} catch (cause) {
-			console.error(`stim-server: could not drop an unregistered push token: ${cause.message}`);
-		}
-	}
-	async checkReceipts(receipts) {
-		let data;
-		try {
-			data = await this.post("getReceipts", { ids: [...receipts.keys()] });
-		} catch {
-			return;
-		}
-		if (!data || typeof data !== "object" || this.closed) return;
-		for (const [id, receipt] of Object.entries(data)) {
-			const to = receipts.get(id);
-			if (to && receipt?.details?.error === "DeviceNotRegistered") this.drop(to);
-			else if (receipt?.status === "error") console.error(`stim-server: a push failed: ${String(receipt.message)}`);
-		}
-	}
-};
-//#endregion
-//#region src/tailscale.ts
-const MAC_APP_BINARY = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
-const TIMEOUT_MS = 3e3;
-/** The tailnet-only HTTPS port the setup command serves stim-server on. */
-const SERVE_PORT = 7443;
-function executable(path) {
-	try {
-		accessSync(path, constants.X_OK);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function findTailscale(env) {
-	for (const dir of (env.PATH ?? "").split(delimiter)) if (dir && executable(join(dir, "tailscale"))) return join(dir, "tailscale");
-	return executable(MAC_APP_BINARY) ? MAC_APP_BINARY : null;
-}
-function parseTailscaleStatus(value) {
-	if (!isJsonObject(value) || typeof value.BackendState !== "string") return {
-		state: "unavailable",
-		reason: "`tailscale status --json` printed no BackendState"
-	};
-	if (value.BackendState !== "Running") return {
-		state: "not-running",
-		backendState: value.BackendState
-	};
-	const self = isJsonObject(value.Self) ? value.Self : {};
-	return {
-		state: "running",
-		ips: Array.isArray(value.TailscaleIPs) ? value.TailscaleIPs.filter((ip) => typeof ip === "string") : [],
-		dnsName: typeof self.DNSName === "string" && self.DNSName ? self.DNSName.replace(/\.$/, "") : null,
-		hostName: typeof self.HostName === "string" && self.HostName ? self.HostName : null
-	};
-}
-function tailscaleStatus(binary, env) {
-	if (!binary) return {
-		state: "unavailable",
-		reason: "the tailscale command was not found"
-	};
-	try {
-		const output = execFileSync(binary, ["status", "--json"], {
-			env,
-			timeout: TIMEOUT_MS,
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		});
-		return parseTailscaleStatus(JSON.parse(output));
-	} catch (error) {
-		return {
-			state: "unavailable",
-			reason: `\`tailscale status --json\` failed: ${error.message}`
-		};
-	}
-}
-function reaches(address, target, hosts) {
-	if (typeof address !== "string") return null;
-	let url;
-	try {
-		url = new URL(address.includes("://") ? address : `tcp://${address}`);
-	} catch {
-		return null;
-	}
-	return hosts.has(url.hostname) && url.port === String(target) ? url : null;
-}
-function portOf(hostPort) {
-	return Number(hostPort.slice(hostPort.lastIndexOf(":") + 1));
-}
-/**
-* Reads `tailscale serve status --json`, an ipn.ServeConfig: `TCP` maps a port to `{ HTTPS }` or
-* `{ TCPForward }`, `Web` maps `<host>:<port>` to `{ Handlers: { <mount>: { Proxy } } }`,
-* `AllowFunnel` maps `<host>:<port>` to true, and `Foreground` holds the same shape per
-* foreground session. Any handler or TCP forward that reaches the server on a Funnel port exposes
-* it; only a `/` HTTP proxy on an HTTPS port is a route a client can use.
-*/
-function parseServeStatus(value, target, ips) {
-	if (!isJsonObject(value)) return {
-		state: "unknown",
-		reason: "it printed no serve config",
-		port: SERVE_PORT
-	};
-	const hosts = /* @__PURE__ */ new Set([
-		"127.0.0.1",
-		"localhost",
-		"[::1]",
-		"0.0.0.0",
-		"[::]",
-		...ips.map((ip) => ip.includes(":") ? `[${ip}]` : ip)
-	]);
-	const configs = [value, ...isJsonObject(value.Foreground) ? Object.values(value.Foreground) : []].filter(isJsonObject);
-	const used = /* @__PURE__ */ new Set();
-	const funneled = /* @__PURE__ */ new Set();
-	const reaching = /* @__PURE__ */ new Set();
-	const routes = /* @__PURE__ */ new Set();
-	for (const config of configs) {
-		const tcp = isJsonObject(config.TCP) ? config.TCP : {};
-		for (const [port, listener] of Object.entries(tcp)) {
-			used.add(Number(port));
-			if (isJsonObject(listener) && reaches(listener.TCPForward, target, hosts)) reaching.add(Number(port));
-		}
-		for (const [hostPort, allowed] of Object.entries(isJsonObject(config.AllowFunnel) ? config.AllowFunnel : {})) if (allowed === true) funneled.add(portOf(hostPort));
-		for (const [hostPort, web] of Object.entries(isJsonObject(config.Web) ? config.Web : {})) {
-			const port = portOf(hostPort);
-			const listener = tcp[String(port)];
-			const https = isJsonObject(listener) && listener.HTTPS === true;
-			const handlers = isJsonObject(web) && isJsonObject(web.Handlers) ? web.Handlers : {};
-			for (const [mount, handler] of Object.entries(handlers)) {
-				const url = isJsonObject(handler) ? reaches(handler.Proxy, target, hosts) : null;
-				if (!url) continue;
-				reaching.add(port);
-				if (https && mount === "/" && url.protocol === "http:" && url.pathname === "/") routes.add(port);
-			}
-		}
-	}
-	let free = SERVE_PORT;
-	while (used.has(free) || funneled.has(free)) free++;
-	const exposed = [...reaching].filter((port) => funneled.has(port)).toSorted((a, b) => a - b);
-	if (exposed.length) return {
-		state: "funneled",
-		ports: exposed,
-		port: free
-	};
-	const tailnet = [...routes].toSorted((a, b) => a - b);
-	if (tailnet.length) return {
-		state: "routed",
-		port: tailnet.includes(SERVE_PORT) ? SERVE_PORT : tailnet[0]
-	};
-	return {
-		state: "missing",
-		port: free
-	};
-}
-function serveRoute(binary, env, target, ips, timeoutMs = TIMEOUT_MS) {
-	if (!binary) return Promise.resolve({
-		state: "unknown",
-		reason: "the tailscale command was not found",
-		port: SERVE_PORT
-	});
-	return new Promise((resolve) => {
-		execFile(binary, [
-			"serve",
-			"status",
-			"--json"
-		], {
-			env,
-			timeout: timeoutMs,
-			killSignal: "SIGKILL",
-			encoding: "utf8"
-		}, (error, stdout) => {
-			let route;
-			try {
-				route = error ? {
-					state: "unknown",
-					reason: error.killed ? "it timed out" : error.message.split("\n")[0],
-					port: SERVE_PORT
-				} : parseServeStatus(stdout.trim() ? JSON.parse(stdout) : {}, target, ips);
-			} catch {
-				route = {
-					state: "unknown",
-					reason: "it printed output that is not JSON",
-					port: SERVE_PORT
-				};
-			}
-			resolve(route);
-		});
-	});
-}
-function tailnetEndpoint(dnsName, port) {
-	return port === 443 ? `wss://${dnsName}` : `wss://${dnsName}:${port}`;
-}
-function serveCommand(port, target) {
-	return `tailscale serve --bg --https=${port} http://127.0.0.1:${target}`;
-}
-/** Reads `tailscale whois --json`: the peer's node (`Node.StableID`, `Node.Name`) and user (`UserProfile.LoginName`). */
-function parseWhois(value) {
-	if (!isJsonObject(value) || !isJsonObject(value.Node)) return null;
-	const { StableID, Name } = value.Node;
-	const login = isJsonObject(value.UserProfile) ? value.UserProfile.LoginName : void 0;
-	if (typeof StableID !== "string" || !StableID) return null;
-	return {
-		kind: "tailnet",
-		nodeId: StableID,
-		nodeName: typeof Name === "string" ? Name.replace(/\.$/, "") : "",
-		user: typeof login === "string" ? login : ""
-	};
-}
-function whois(binary, env, ip) {
-	if (!binary) return Promise.resolve(null);
-	return new Promise((resolve) => {
-		execFile(binary, [
-			"whois",
-			"--json",
-			ip
-		], {
-			env,
-			timeout: TIMEOUT_MS,
-			encoding: "utf8"
-		}, (error, stdout) => {
-			if (error) return resolve(null);
-			try {
-				resolve(parseWhois(JSON.parse(stdout)));
-			} catch {
-				resolve(null);
-			}
-		});
-	});
-}
-//#endregion
-//#region src/server.ts
-function healthTailscale(tailscale) {
-	if (tailscale.state === "running") return {
-		state: "running",
-		dnsName: tailscale.dnsName
-	};
-	if (tailscale.state === "not-running") return {
-		state: "not-running",
-		backendState: tailscale.backendState
-	};
-	return {
-		state: "unavailable",
-		reason: tailscale.reason
-	};
-}
-/** Only a request made to this Mac's loopback name, so a DNS-rebound web page cannot read the health payload. */
-function localHealthRequest(request) {
-	const host = request.headers.host?.replace(/:\d+$/, "");
-	return request.method === "GET" && request.url === "/health" && (host === "127.0.0.1" || host === "localhost") && peerAddress(request) === null;
-}
-const CLOSE_UNAUTHORIZED = 4401;
-const CLOSE_BAD_REQUEST = 4400;
-const CLOSE_AUTH_TIMEOUT = 4408;
-const MAX_PAYLOAD = 65536;
-const MAX_SUBSCRIPTIONS = 32;
-const MAX_COMMANDS = 4;
-const LOG_LIMITS = {
-	maxBufferedBytes: 4194304,
-	maxPendingRecords: 2e4
-};
-const FRAME_BUFFER_FRAMES = 2;
-const FRAME_RETRY_MS = 50;
-const HELPER_RETRY_MS = 3e5;
-const CONTROL_LIMITS = {
-	idleMs: 3e5,
-	renewMs: 6e4,
-	leaseFor: "2m",
-	inputPerSecond: 120,
-	textCharsPerSecond: 40,
-	shapeChangesPerSecond: 2,
-	foldTimeoutMs: 4e4
-};
-const LOCK_LIMITS = {
-	timeoutMs: 3e4,
-	maxOutputBytes: 65536
-};
-const pushToken = new RegExp(PUSH_TOKEN_PATTERN);
-const STATUS_FEED = {
-	args: [
-		"status",
-		"--watch",
-		"--json"
-	],
-	cwd: homedir(),
-	keep: 1,
-	label: "stim status --watch"
-};
-const HEALTH_ROUTE_TIMEOUT_MS = 1e3;
-const COMMAND_LIMITS = {
-	timeoutMs: 6e4,
-	maxOutputBytes: 33554432
-};
-const PLAN_TIMEOUT_MS = 15e4;
-const AUDIT_FIELD_CHARS = 256;
-const ACTION_LIMITS = {
-	timeoutMs: 12e4,
-	maxOutputBytes: 1048576
-};
-const AUTH_REFUSALS = {
-	"pairing-unknown": {
-		code: "pairing-expired",
-		message: "This pairing code is unknown or was already used. Pair again."
-	},
-	"pairing-expired": {
-		code: "pairing-expired",
-		message: "This pairing code expired. Pair again."
-	},
-	"device-unknown": {
-		code: "unauthorized",
-		message: "This Mac does not recognize this device token. Pair again."
-	},
-	"node-mismatch": {
-		code: "unauthorized",
-		message: "This device token was paired from a different tailnet node."
-	}
-};
-function isLoopback(address) {
-	return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
-}
-/**
-* The tailnet address of the peer. `tailscale serve` proxies from loopback and names the peer in
-* X-Forwarded-For; a loopback connection without that header comes from this Mac.
-*/
-function peerAddress(request) {
-	const remote = request.socket.remoteAddress;
-	if (!isLoopback(remote)) return remote ?? null;
-	const forwarded = request.headers["x-forwarded-for"];
-	return (Array.isArray(forwarded) ? forwarded[0] : forwarded)?.split(",")[0]?.trim() || null;
-}
-var FailureLimiter = class {
-	failures = /* @__PURE__ */ new Map();
-	max;
-	windowMs;
-	constructor(max, windowMs) {
-		this.max = max;
-		this.windowMs = windowMs;
-	}
-	recent(key, now) {
-		const kept = (this.failures.get(key) ?? []).filter((at) => now - at < this.windowMs);
-		if (kept.length) this.failures.set(key, kept);
-		else this.failures.delete(key);
-		return kept;
-	}
-	blocked(key, now = Date.now()) {
-		return this.recent(key, now).length >= this.max;
-	}
-	record(key, now = Date.now()) {
-		this.failures.set(key, [...this.recent(key, now), now]);
-	}
-};
-function auditSafely(record) {
-	try {
-		appendAudit(record);
-	} catch (cause) {
-		console.error(`stim-server: could not append to the action log: ${cause.message}`);
-	}
-}
-function take(bucket, cost, perSecond, capacity) {
-	const now = Date.now();
-	bucket.tokens = Math.min(capacity, bucket.tokens + (now - bucket.at) / 1e3 * perSecond);
-	bucket.at = now;
-	if (bucket.tokens < cost) return false;
-	bucket.tokens -= cost;
-	return true;
-}
-function send(socket, message) {
-	if (socket.readyState === socket.OPEN) socket.send(typeof message === "string" ? message : JSON.stringify(message));
-}
-function requestId(value) {
-	return typeof value === "number" || typeof value === "string" ? value : null;
-}
-function registeredWorkspace(workspace) {
-	if (typeof workspace !== "string") return {
-		code: "bad-request",
-		message: "params.workspace must be an environment path from a status payload."
-	};
-	let projects;
-	try {
-		projects = loadConfig()?.projects ?? {};
-	} catch (cause) {
-		return {
-			code: "stim-failed",
-			message: cause.message
-		};
-	}
-	const dir = Object.keys(projects).find((path) => path === workspace);
-	if (dir === void 0) return {
-		code: "unknown-workspace",
-		message: `${workspace} is not a Stim workspace on this Mac.`
-	};
-	if (!existsSync(dir)) return {
-		code: "unknown-workspace",
-		message: `${dir} is registered but no longer exists on this Mac.`
-	};
-	return { dir };
-}
-async function startServer(options) {
-	const limiter = new FailureLimiter(options.maxAuthFailures ?? 5, options.failureWindowMs ?? 6e4);
-	const authTimeoutMs = options.authTimeoutMs ?? 5e3;
-	const feeds = new FeedPool(options.stimCli, options.env);
-	const frameLimits = {
-		...DEFAULT_FRAME_LIMITS,
-		...options.frameLimits
-	};
-	let helperPath = options.frameHelper ?? null;
-	let helperBuilding = false;
-	let helperRetryAt = 0;
-	const helperAbort = new AbortController();
-	const buildHelper = () => {
-		helperBuilding = true;
-		(async () => {
-			try {
-				helperPath = await buildFrameHelper(options.env, helperAbort.signal);
-			} catch (cause) {
-				helperRetryAt = Date.now() + HELPER_RETRY_MS;
-				if (!helperAbort.signal.aborted) console.error(`stim-server: frames come from screenshots: ${cause.message}`);
-			} finally {
-				helperBuilding = false;
-			}
-		})();
-	};
-	const frameHelper = () => {
-		if (options.frameHelper === void 0 && !helperPath && !helperBuilding && Date.now() >= helperRetryAt) buildHelper();
-		return helperPath;
-	};
-	if (options.frameHelper === void 0) buildHelper();
-	const frames = new FramePool(options.env, frameLimits, frameHelper);
-	let foldBuild = null;
-	const foldHelper = () => {
-		if (options.foldHelper !== void 0) return Promise.resolve(options.foldHelper);
-		foldBuild ??= buildFoldHelper(options.env, helperAbort.signal).catch((cause) => {
-			foldBuild = null;
-			throw new Error(`sim-fold could not be built: ${cause.message}`);
-		});
-		return foldBuild;
-	};
-	const running = /* @__PURE__ */ new Set();
-	const logLimits = {
-		...LOG_LIMITS,
-		...options.logLimits
-	};
-	const commandLimits = {
-		...COMMAND_LIMITS,
-		...options.commandLimits
-	};
-	const actionLimits = {
-		...ACTION_LIMITS,
-		...options.actionLimits
-	};
-	const busyWorkspaces = /* @__PURE__ */ new Set();
-	const planQueues = /* @__PURE__ */ new Map();
-	const sessions = /* @__PURE__ */ new Map();
-	const sampler = new UsageSampler();
-	const controllers = /* @__PURE__ */ new Map();
-	const controlLimits = {
-		...CONTROL_LIMITS,
-		...options.controlLimits
-	};
-	const control = new ControlHub({
-		env: options.env,
-		stimCli: options.stimCli,
-		feeds,
-		frames,
-		statusFeed: STATUS_FEED,
-		audit: auditSafely,
-		lockLimits: LOCK_LIMITS,
-		idleMs: controlLimits.idleMs,
-		renewMs: controlLimits.renewMs,
-		leaseFor: controlLimits.leaseFor,
-		foldHelper,
-		foldTimeoutMs: controlLimits.foldTimeoutMs
-	});
-	const wss = new WebSocketServer({
-		noServer: true,
-		maxPayload: MAX_PAYLOAD
-	});
-	const push = new PushNotifier({
-		name: options.name,
-		endpoint: options.pushEndpoint ?? "https://exp.host/--/api/v2/push",
-		subscribeStatus: (listener) => feeds.subscribe(STATUS_FEED, listener),
-		readVolumes: readDiskVolumes,
-		devices: readDevices,
-		dropToken: dropPushToken,
-		limits: options.pushLimits
-	});
-	mkdirSync(serverDir(), {
-		recursive: true,
-		mode: 448
-	});
-	let revocationCheck = null;
-	const watcher = watch(serverDir(), () => {
-		revocationCheck ??= setTimeout(() => {
-			revocationCheck = null;
-			const paired = new Map(readDevices().map((device) => [device.id, device]));
-			push.refresh();
-			for (const [socket, device] of sessions) if (!paired.has(device.id)) socket.close(CLOSE_UNAUTHORIZED, "device revoked");
-			for (const [socket, controller] of controllers) if (!paired.get(controller.device.id)?.capabilities.includes("control")) {
-				control.endFor(controller, "forbidden", "This device can no longer control devices.");
-				controllers.delete(socket);
-			}
-		}, 50);
-	});
-	function connection(socket, peer) {
-		const limitKey = peer ?? "local";
-		const subscriptions = /* @__PURE__ */ new Map();
-		const keyframes = /* @__PURE__ */ new Map();
-		const commands = /* @__PURE__ */ new Set();
-		let nextSubscription = 1;
-		let device = null;
-		let queue = Promise.resolve();
-		const refuse = (id, code, message, closeCode) => {
-			if (!device) limiter.record(limitKey);
-			send(socket, {
-				id,
-				error: {
-					code,
-					message
-				}
-			});
-			socket.close(closeCode, code);
-		};
-		const timer = setTimeout(() => {
-			limiter.record(limitKey);
-			socket.close(CLOSE_AUTH_TIMEOUT, "authentication timeout");
-		}, authTimeoutMs);
-		async function identify() {
-			if (peer === null) return { kind: "local" };
-			return isIP(peer) ? whois(options.tailscale, options.env, peer) : null;
-		}
-		async function hello(id, params) {
-			if (device) return send(socket, {
-				id,
-				error: {
-					code: "already-authenticated",
-					message: "hello was already accepted."
-				}
-			});
-			const auth = isJsonObject(params) && isJsonObject(params.auth) ? params.auth : null;
-			if (!isJsonObject(params) || !auth || !isJsonObject(params.client)) return refuse(id, "bad-request", "hello needs params.client and params.auth.", CLOSE_BAD_REQUEST);
-			if (params.protocol !== 1) return refuse(id, "protocol-unsupported", `This server speaks protocol 1.`, CLOSE_BAD_REQUEST);
-			clearTimeout(timer);
-			const identity = await identify();
-			if (socket.readyState !== socket.OPEN) return;
-			if (!identity) return refuse(id, "identity-unavailable", `tailscale whois did not identify ${peer}.`, CLOSE_UNAUTHORIZED);
-			let outcome;
-			if (typeof auth.pairingToken === "string" && typeof auth.deviceName === "string" && auth.deviceName.trim()) outcome = spendPairingToken(auth.pairingToken, auth.deviceName.trim(), identity);
-			else if (typeof auth.deviceToken === "string") outcome = authenticateDevice(auth.deviceToken, identity);
-			else return refuse(id, "bad-request", "auth needs pairingToken and deviceName, or deviceToken.", CLOSE_BAD_REQUEST);
-			if (!outcome.ok) {
-				const { code, message } = AUTH_REFUSALS[outcome.reason];
-				return refuse(id, code, message, CLOSE_UNAUTHORIZED);
-			}
-			device = outcome.device;
-			sessions.set(socket, device);
-			sampler.start();
-			send(socket, {
-				id,
-				result: {
-					protocol: 1,
-					server: {
-						name: options.name,
-						version: options.serverVersion,
-						stim: options.stimVersion,
-						home: homedir()
-					},
-					capabilities: device.capabilities,
-					actions: device.capabilities.includes("control") ? [...ACTIONS] : [],
-					device: {
-						id: device.id,
-						name: device.name
-					},
-					...outcome.deviceToken ? { deviceToken: outcome.deviceToken } : {}
-				}
-			});
-		}
-		function error(id, code, message) {
-			send(socket, {
-				id,
-				error: {
-					code,
-					message
-				}
-			});
-		}
-		const inputs = {
-			tokens: controlLimits.inputPerSecond,
-			at: Date.now()
-		};
-		const characters = {
-			tokens: 256,
-			at: Date.now()
-		};
-		const shapeChanges = {
-			tokens: controlLimits.shapeChangesPerSecond,
-			at: Date.now()
-		};
-		function controller(session) {
-			let found = controllers.get(socket);
-			if (!found) {
-				found = {
-					device: session,
-					send: (message) => send(socket, message)
-				};
-				controllers.set(socket, found);
-			}
-			return found;
-		}
-		async function beginControl(id, params, session) {
-			const raw = isJsonObject(params) ? params : {};
-			const clip = (value) => typeof value === "string" ? value.slice(0, AUDIT_FIELD_CHARS) : null;
-			const refuseControl = (code, message) => {
-				auditSafely({
-					at: (/* @__PURE__ */ new Date()).toISOString(),
-					device: {
-						id: session.id,
-						name: session.name
-					},
-					action: raw.takeOver === true ? "control.take-over" : "control.begin",
-					workspace: clip(raw.workspace),
-					...typeof raw.platform === "string" ? { platform: clip(raw.platform) } : {},
-					ok: false,
-					error: {
-						code,
-						message: clip(message)
-					}
-				});
-				error(id, code, message);
-			};
-			if (!readDevices().find((entry) => entry.id === session.id)?.capabilities.includes("control")) return refuseControl("forbidden", `This device can only read. On the Mac, run \`stim-server devices grant ${session.id} --control\` to let it control devices.`);
-			const parsed = parseControlBegin(params);
-			if ("code" in parsed) return refuseControl(parsed.code, parsed.message);
-			const resolved = registeredWorkspace(parsed.value.workspace);
-			if ("code" in resolved) return refuseControl(resolved.code, resolved.message);
-			const owner = controller(session);
-			const outcome = await control.begin(owner, {
-				...parsed.value,
-				workspace: resolved.dir
-			}, resolved.dir, () => socket.readyState === socket.OPEN && controllers.get(socket) === owner && readDevices().some((entry) => entry.id === session.id && entry.capabilities.includes("control")));
-			if ("code" in outcome) return refuseControl(outcome.code, outcome.message);
-			send(socket, {
-				id,
-				result: outcome
-			});
-		}
-		async function input(id, method, params, session) {
-			const owner = controller(session);
-			const parsed = parseInput(method, params, (name) => control.targetOf(owner, name));
-			if ("code" in parsed) return error(id, parsed.code, parsed.message);
-			if (!take(inputs, 1, controlLimits.inputPerSecond, controlLimits.inputPerSecond)) return error(id, "limit-exceeded", `A connection can send ${controlLimits.inputPerSecond} inputs a second.`);
-			const { command: sent } = parsed.value;
-			if (sent.input === "text" && !take(characters, sent.text.length, controlLimits.textCharsPerSecond, 256)) return error(id, "limit-exceeded", `A connection can type ${controlLimits.textCharsPerSecond} characters a second. Send the rest shortly.`);
-			const { shapeChangesPerSecond } = controlLimits;
-			if ((sent.input === "rotate" || sent.input === "posture") && !take(shapeChanges, 1, shapeChangesPerSecond, shapeChangesPerSecond)) return error(id, "limit-exceeded", `A connection can rotate or fold ${shapeChangesPerSecond} times a second.`);
-			const refused = await control.input(owner, parsed.value.session, parsed.value.command);
-			if (refused) return error(id, refused.code, refused.message);
-			send(socket, {
-				id,
-				result: {}
-			});
-		}
-		function workspaceDir(id, workspace, required) {
-			if (workspace === void 0 && !required) return homedir();
-			const resolved = registeredWorkspace(workspace);
-			if ("code" in resolved) {
-				error(id, resolved.code, resolved.message);
-				return null;
-			}
-			return resolved.dir;
-		}
-		function openSubscription(id, result = {}) {
-			if (subscriptions.size >= MAX_SUBSCRIPTIONS) {
-				error(id, "limit-exceeded", `A connection can hold ${MAX_SUBSCRIPTIONS} subscriptions.`);
-				return null;
-			}
-			const subscription = `s${nextSubscription++}`;
-			send(socket, {
-				id,
-				result: {
-					subscription,
-					...result
-				}
-			});
-			return subscription;
-		}
-		function subscribeStatus(id) {
-			const subscription = openSubscription(id);
-			if (!subscription) return;
-			const envelope = `{"event":"status","subscription":${JSON.stringify(subscription)},"payload":`;
-			const unsubscribe = feeds.subscribe(STATUS_FEED, {
-				item: (_payload, text) => send(socket, `${envelope}${text}}`),
-				failed: (message) => {
-					subscriptions.delete(subscription);
-					send(socket, {
-						event: "error",
-						subscription,
-						error: {
-							code: "status-failed",
-							message
-						}
-					});
-				}
-			});
-			subscriptions.set(subscription, unsubscribe);
-		}
-		function subscribeLogs(id, params) {
-			const parsed = parseLogFilter(params);
-			if ("error" in parsed) return error(id, "bad-request", parsed.error);
-			const cwd = workspaceDir(id, parsed.filter.workspace, true);
-			if (!cwd) return;
-			const subscription = openSubscription(id);
-			if (!subscription) return;
-			const end = () => {
-				subscriptions.get(subscription)?.();
-				subscriptions.delete(subscription);
-			};
-			const batcher = new LogBatcher({
-				send: (records) => send(socket, {
-					event: "logs",
-					subscription,
-					records
-				}),
-				bufferedBytes: () => socket.bufferedAmount,
-				overflow: () => {
-					end();
-					send(socket, {
-						event: "error",
-						subscription,
-						error: {
-							code: "slow-client",
-							message: "This client fell behind the log stream. Subscribe again."
-						}
-					});
-				}
-			}, logLimits);
-			const unsubscribe = feeds.subscribe({
-				args: logArgs(parsed.filter, true),
-				cwd,
-				keep: parsed.filter.tail,
-				label: "stim logs --follow"
-			}, {
-				item: (record) => batcher.push(record),
-				failed: (message) => {
-					batcher.flush(true);
-					batcher.stop();
-					subscriptions.delete(subscription);
-					send(socket, {
-						event: "error",
-						subscription,
-						error: {
-							code: "logs-failed",
-							message
-						}
-					});
-				}
-			});
-			subscriptions.set(subscription, () => {
-				batcher.stop();
-				unsubscribe();
-			});
-		}
-		function subscribeFrames(id, params) {
-			const { workspace, platform, slot, fps, maxEdge, video } = isJsonObject(params) ? params : {};
-			if (typeof workspace !== "string" || platform !== "ios" && platform !== "android") return error(id, "bad-request", "frames.subscribe needs params.workspace and params.platform (ios or android).");
-			if (slot !== void 0 && (typeof slot !== "string" || slot === "")) return error(id, "bad-request", "slot must be a slot name.");
-			if (video !== void 0 && (!Array.isArray(video) || !video.every((codec) => typeof codec === "string"))) return error(id, "bad-request", "video must be a list of codec names.");
-			const wantsVideo = video?.includes("h264") === true;
-			const offersVideo = wantsVideo && frameHelper() !== null;
-			const maxFps = wantsVideo ? FRAME_FPS.video : FRAME_FPS.max;
-			if (fps !== void 0 && (!Number.isInteger(fps) || fps < 1 || fps > maxFps)) return error(id, "bad-request", `fps must be a whole number from 1 to ${maxFps}.`);
-			if (maxEdge !== void 0 && (!Number.isInteger(maxEdge) || maxEdge < FRAME_EDGE.min || maxEdge > FRAME_EDGE.max)) return error(id, "bad-request", `maxEdge must be a whole number of pixels from ${FRAME_EDGE.min} to ${FRAME_EDGE.max}.`);
-			const hint = {
-				fps: Math.min(fps ?? FRAME_FPS.default, offersVideo ? FRAME_FPS.video : FRAME_FPS.max),
-				maxEdge: maxEdge ?? FRAME_EDGE.default
-			};
-			if (!workspaceDir(id, workspace, true)) return;
-			const subscription = openSubscription(id, offersVideo ? { video: "h264" } : {});
-			if (!subscription) return;
-			const frameTarget = {
-				workspace,
-				platform,
-				...slot ? { slot } : {}
-			};
-			const gate = new VideoGate(DEFAULT_VIDEO_LIMITS.congestedBytes);
-			let sequence = 0;
-			let streamed = null;
-			let draining = null;
-			const drain = () => {
-				draining = null;
-				if (ended || !streamed) return;
-				if (socket.bufferedAmount <= DEFAULT_VIDEO_LIMITS.congestedBytes) return frames.keyframe(streamed);
-				frames.congested(streamed);
-				draining = setTimeout(drain, FRAME_RETRY_MS);
-			};
-			let attached = null;
-			let detach = null;
-			let pending = null;
-			let retry = null;
-			let ended = false;
-			let sentAt = 0;
-			const flush = () => {
-				retry = null;
-				if (!pending || ended) return;
-				const wait = sentAt + 1e3 / hint.fps - Date.now();
-				if (wait > 0) {
-					retry = setTimeout(flush, wait);
-					return;
-				}
-				if (socket.bufferedAmount > FRAME_BUFFER_FRAMES * pending.data.length) {
-					retry = setTimeout(flush, FRAME_RETRY_MS);
-					return;
-				}
-				const frame = pending;
-				pending = null;
-				sentAt = Date.now();
-				send(socket, {
-					event: "frame",
-					subscription,
-					platform,
-					slot: slot ?? "default",
-					mime: "image/jpeg",
-					...frame
-				});
-			};
-			const cleanup = () => {
-				ended = true;
-				keyframes.delete(subscription);
-				if (retry) clearTimeout(retry);
-				if (draining) clearTimeout(draining);
-				detach?.();
-				detach = null;
-				unsubscribeStatus?.();
-			};
-			const end = (message) => {
-				if (ended) return;
-				cleanup();
-				subscriptions.delete(subscription);
-				send(socket, {
-					event: "error",
-					subscription,
-					error: {
-						code: "frames-failed",
-						message
-					}
-				});
-			};
-			const listener = {
-				frame: (frame) => {
-					pending = frame;
-					if (!retry) flush();
-				},
-				delayed: (delayed) => {
-					if (!ended) send(socket, {
-						event: "frame-delayed",
-						subscription,
-						delayed
-					});
-				},
-				failed: end,
-				...offersVideo ? { video: (unit) => {
-					if (ended || socket.readyState !== socket.OPEN) return;
-					const verdict = gate.admit(unit, socket.bufferedAmount);
-					if (verdict === "send") socket.send(videoPacket(subscription, sequence++, unit));
-					else if (verdict === "congested" && !draining) drain();
-				} } : {}
-			};
-			if (offersVideo) keyframes.set(subscription, () => {
-				gate.reset();
-				if (streamed) frames.keyframe(streamed);
-			});
-			let unsubscribeStatus = null;
-			unsubscribeStatus = feeds.subscribe(STATUS_FEED, {
-				item: (payload) => {
-					if (ended) return;
-					const resolved = ownedDevice(payload, frameTarget, attached);
-					if (typeof resolved === "string") return queueMicrotask(() => end(resolved));
-					if (deviceKey(resolved) === attached) return;
-					detach?.();
-					gate.reset();
-					streamed = resolved;
-					attached = deviceKey(resolved);
-					detach = frames.subscribe(resolved, listener, hint);
-				},
-				failed: (message) => queueMicrotask(() => end(message))
-			});
-			subscriptions.set(subscription, cleanup);
-		}
-		function command(id, args, cwd, result, limits = commandLimits, turn = null) {
-			if (commands.size >= MAX_COMMANDS) {
-				error(id, "limit-exceeded", `A connection can run ${MAX_COMMANDS} requests at a time.`);
-				return null;
-			}
-			let run = null;
-			let dropped = false;
-			let release;
-			const released = new Promise((resolve) => {
-				release = resolve;
-			});
-			const cancel = async () => {
-				dropped = true;
-				if (!run) return void (turn ?? Promise.resolve()).then(release);
-				await run.cancel();
-				release();
-			};
-			const start = async () => {
-				if (dropped) return;
-				run = runStim(options.stimCli, options.env, args, cwd, limits);
-				const outcome = await run.outcome;
-				commands.delete(cancel);
-				running.delete(cancel);
-				try {
-					if (!outcome.ok) {
-						const printed = actionOutcome(outcome);
-						return error(id, "stim-failed", printed.ok ? outcome.message : printed.error.message);
-					}
-					let value;
-					try {
-						value = result(outcome.stdout);
-					} catch {
-						return error(id, "stim-failed", `stim ${args[0]} printed output that is not JSON.`);
-					}
-					send(socket, {
-						id,
-						result: value
-					});
-				} finally {
-					release();
-				}
-			};
-			commands.add(cancel);
-			running.add(cancel);
-			if (turn) turn.then(start);
-			else start();
-			return released;
-		}
-		function queryLogs(id, params) {
-			const parsed = parseLogFilter(params);
-			if ("error" in parsed) return error(id, "bad-request", parsed.error);
-			const cwd = workspaceDir(id, parsed.filter.workspace, true);
-			if (!cwd) return;
-			command(id, logArgs(parsed.filter, false), cwd, (stdout) => ({ records: stdout.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line)) }));
-		}
-		function workspaceCommand(id, method, params) {
-			if (params !== void 0 && !isJsonObject(params)) return error(id, "bad-request", "params must be an object.");
-			const cwd = workspaceDir(id, params?.workspace, false);
-			if (!cwd) return;
-			command(id, [method === "stats.get" ? "stats" : "settings", "--json"], cwd, (stdout) => {
-				const value = JSON.parse(stdout);
-				if (!isJsonObject(value)) throw new Error("not an object");
-				return value;
-			});
-		}
-		function runAction(id, params, session) {
-			const startedAt = Date.now();
-			const raw = isJsonObject(params) ? params : {};
-			const clip = (value) => typeof value === "string" ? value.slice(0, AUDIT_FIELD_CHARS) : null;
-			const record = {
-				at: new Date(startedAt).toISOString(),
-				device: {
-					id: session.id,
-					name: session.name
-				},
-				action: clip(raw.action),
-				workspace: clip(raw.workspace),
-				...typeof raw.platform === "string" ? { platform: clip(raw.platform) } : {},
-				ok: false
-			};
-			const audit = (outcome) => {
-				const logged = outcome.error ? {
-					...outcome.error,
-					message: clip(outcome.error.message)
-				} : void 0;
-				try {
-					appendAudit({
-						...record,
-						...outcome,
-						...logged ? { error: logged } : {}
-					});
-				} catch (cause) {
-					console.error(`stim-server: could not append to the action log: ${cause.message}`);
-				}
-			};
-			const refuseAction = (code, message) => {
-				audit({
-					ok: false,
-					error: {
-						code,
-						message
-					}
-				});
-				error(id, code, message);
-			};
-			if (!readDevices().find((entry) => entry.id === session.id)?.capabilities.includes("control")) return refuseAction("forbidden", `This device can only read. On the Mac, run \`stim-server devices grant ${session.id} --control\` to let it run actions.`);
-			const parsed = parseAction(params);
-			if ("code" in parsed) return refuseAction(parsed.code, parsed.message);
-			const { action } = parsed;
-			const resolved = registeredWorkspace(action.workspace);
-			if ("code" in resolved) return refuseAction(resolved.code, resolved.message);
-			if (busyWorkspaces.has(resolved.dir)) return refuseAction("action-busy", `An action is already running in ${resolved.dir}. Try again when it finishes.`);
-			let run;
-			try {
-				run = runStim(options.stimCli, options.env, actionArgs(action), resolved.dir, actionLimits);
-			} catch (cause) {
-				return refuseAction("action-failed", `stim ${action.action} could not start (${cause.message}).`);
-			}
-			busyWorkspaces.add(resolved.dir);
-			let finished = false;
-			const finish = (outcome) => {
-				if (finished) return;
-				finished = true;
-				running.delete(cancel);
-				busyWorkspaces.delete(resolved.dir);
-				audit({
-					ok: outcome.ok,
-					...outcome.ok ? {} : { error: outcome.error },
-					durationMs: Date.now() - startedAt
-				});
-				if (outcome.ok) send(socket, {
-					id,
-					result: {
-						action: action.action,
-						workspace: resolved.dir,
-						output: outcome.output
-					}
-				});
-				else send(socket, {
-					id,
-					error: outcome.error
-				});
-			};
-			const cancel = async () => {
-				finish({
-					ok: false,
-					error: {
-						code: "action-failed",
-						message: "stim-server stopped before the action finished."
-					}
-				});
-				await run.cancel();
-			};
-			running.add(cancel);
-			run.outcome.then((outcome) => finish(actionOutcome(outcome)));
-		}
-		function planBuild(id, params) {
-			if (!isJsonObject(params)) return error(id, "bad-request", "params must be an object.");
-			const { platform, slot } = params;
-			if (platform !== "ios" && platform !== "android") return error(id, "bad-request", "params.platform must be ios or android.");
-			if (slot !== void 0 && (typeof slot !== "string" || !SLOT_NAME.test(slot))) return error(id, "bad-request", "params.slot must be 1-64 letters, digits, underscores or hyphens.");
-			const cwd = workspaceDir(id, params.workspace, true);
-			if (!cwd) return;
-			const finished = command(id, [
-				platform,
-				"--plan",
-				"--json",
-				...slot === void 0 ? [] : [`--slot=${slot}`]
-			], cwd, (stdout) => {
-				const value = JSON.parse(stdout);
-				if (!isJsonObject(value) || value.platform !== platform) throw new Error("not a plan");
-				return value;
-			}, {
-				...commandLimits,
-				timeoutMs: options.commandLimits?.timeoutMs ?? PLAN_TIMEOUT_MS
-			}, planQueues.get(cwd) ?? null);
-			if (!finished) return;
-			planQueues.set(cwd, finished);
-			finished.finally(() => {
-				if (planQueues.get(cwd) === finished) planQueues.delete(cwd);
-			});
-		}
-		function registerPush(id, params, session) {
-			const token = isJsonObject(params) ? params.token : void 0;
-			const events = isJsonObject(params) ? params.events : void 0;
-			const agentOnly = isJsonObject(params) ? params.agentOnly === void 0 ? false : params.agentOnly : void 0;
-			const ref = isJsonObject(params) ? params.ref : void 0;
-			if (typeof token !== "string" || !pushToken.test(token) || !Array.isArray(events) || events.length === 0 || !events.every((event) => PUSH_EVENTS.includes(event)) || typeof agentOnly !== "boolean" || typeof ref !== "string" || ref.length === 0 || ref.length > 128) return error(id, "bad-request", `push.register takes an Expo push token, one or more events from ${PUSH_EVENTS.join(", ")}, an optional boolean agentOnly and a ref of 1 to 128 characters.`);
-			if (!setDevicePush(session.id, {
-				token,
-				events: PUSH_EVENTS.filter((event) => events.includes(event)),
-				agentOnly,
-				ref,
-				registeredAt: (/* @__PURE__ */ new Date()).toISOString()
-			})) return error(id, "unauthorized", "This device is no longer paired.");
-			push.refresh();
-			send(socket, {
-				id,
-				result: {}
-			});
-		}
-		async function handle(raw) {
-			if (socket.readyState !== socket.OPEN) return;
-			let message;
-			try {
-				message = JSON.parse(raw);
-			} catch {
-				message = null;
-			}
-			const id = isJsonObject(message) ? requestId(message.id) : null;
-			if (!isJsonObject(message) || id === null || typeof message.method !== "string") {
-				if (device) return send(socket, {
-					id,
-					error: {
-						code: "bad-request",
-						message: "Expected {id, method, params}."
-					}
-				});
-				return refuse(id, "bad-request", "Expected {id, method, params}.", CLOSE_BAD_REQUEST);
-			}
-			if (message.method === "hello") return hello(id, message.params);
-			if (!device) return refuse(id, "unauthorized", "Send hello first.", CLOSE_UNAUTHORIZED);
-			if (message.method === "status.subscribe") return subscribeStatus(id);
-			if (message.method === "logs.subscribe") return subscribeLogs(id, message.params);
-			if (message.method === "logs.query") return queryLogs(id, message.params);
-			if (message.method === "frames.subscribe") return subscribeFrames(id, message.params);
-			if (message.method === "frames.keyframe") {
-				const name = isJsonObject(message.params) ? message.params.subscription : void 0;
-				const keyframe = typeof name === "string" ? keyframes.get(name) : void 0;
-				if (!keyframe) return send(socket, {
-					id,
-					error: {
-						code: "unknown-subscription",
-						message: `No video subscription ${String(name)}.`
-					}
-				});
-				keyframe();
-				return send(socket, {
-					id,
-					result: {}
-				});
-			}
-			if (message.method === "build.plan") return planBuild(id, message.params);
-			if (message.method === "machine.get") return send(socket, {
-				id,
-				result: await readMachineUsage()
-			});
-			if (message.method === "machine.history") {
-				const params = message.params ?? {};
-				const sinceMs = isJsonObject(params) ? params.sinceMs : void 0;
-				if (!isJsonObject(params) || sinceMs !== void 0 && typeof sinceMs !== "number") return error(id, "bad-request", "machine.history takes an optional numeric sinceMs.");
-				return send(socket, {
-					id,
-					result: sampler.history(sinceMs)
-				});
-			}
-			if (message.method === "stats.get" || message.method === "settings.get") return workspaceCommand(id, message.method, message.params);
-			if (message.method === "action") return runAction(id, message.params, device);
-			if (message.method === "control.begin") {
-				beginControl(id, message.params, device);
-				return;
-			}
-			if (message.method === "control.end") {
-				const name = isJsonObject(message.params) ? message.params.session : void 0;
-				if (typeof name !== "string" || !control.endById(controller(device), name)) return error(id, "unknown-session", `No control session ${String(name)} on this connection.`);
-				return send(socket, {
-					id,
-					result: {}
-				});
-			}
-			if (message.method === "input.touch" || message.method === "input.text" || message.method === "input.button" || message.method === "input.rotate" || message.method === "input.posture") {
-				const method = message.method;
-				input(id, method, message.params, device);
-				return;
-			}
-			if (message.method === "push.register") return registerPush(id, message.params, device);
-			if (message.method === "push.unregister") {
-				setDevicePush(device.id, null);
-				push.refresh();
-				return send(socket, {
-					id,
-					result: {}
-				});
-			}
-			if (message.method === "unsubscribe") {
-				const name = isJsonObject(message.params) ? message.params.subscription : void 0;
-				const unsubscribe = typeof name === "string" ? subscriptions.get(name) : void 0;
-				if (!unsubscribe) return send(socket, {
-					id,
-					error: {
-						code: "unknown-subscription",
-						message: `No subscription ${String(name)}.`
-					}
-				});
-				subscriptions.delete(name);
-				unsubscribe();
-				return send(socket, {
-					id,
-					result: {}
-				});
-			}
-			send(socket, {
-				id,
-				error: {
-					code: "unknown-method",
-					message: `Unknown method ${message.method}.`
-				}
-			});
-		}
-		socket.on("message", (data) => {
-			const raw = data.toString();
-			queue = queue.then(() => handle(raw)).catch(() => socket.close(1011, "internal error"));
-		});
-		socket.on("close", () => {
-			clearTimeout(timer);
-			sessions.delete(socket);
-			if (sessions.size === 0) sampler.stop();
-			const owner = controllers.get(socket);
-			if (owner) control.endFor(owner, null, "The client disconnected.");
-			controllers.delete(socket);
-			for (const unsubscribe of subscriptions.values()) unsubscribe();
-			subscriptions.clear();
-			for (const cancel of commands) {
-				running.delete(cancel);
-				cancel();
-			}
-			commands.clear();
-		});
-	}
-	function upgrade(request, socket, head) {
-		const peer = peerAddress(request);
-		if (limiter.blocked(peer ?? "local")) {
-			socket.end("HTTP/1.1 429 Too Many Requests\r\nConnection: close\r\nContent-Length: 0\r\n\r\n");
-			return;
-		}
-		wss.handleUpgrade(request, socket, head, (ws) => connection(ws, peer));
-	}
-	const health = {
-		server: "stim-server",
-		name: options.name,
-		version: options.serverVersion,
-		stim: options.stimVersion,
-		protocol: 1,
-		stimHome: configDir(),
-		tailscale: healthTailscale(options.tailscaleState)
-	};
-	const answerHealth = async (response) => {
-		const tailscale = options.tailscaleState;
-		const route = tailscale.state === "running" && tailscale.dnsName ? await serveRoute(options.tailscale, options.env, addresses[0].port, tailscale.ips, HEALTH_ROUTE_TIMEOUT_MS) : void 0;
-		response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify({
-			...health,
-			route
-		}));
-	};
-	const servers = [];
-	const addresses = [];
-	push.refresh();
-	const close = async () => {
-		push.close();
-		watcher.close();
-		helperAbort.abort();
-		sampler.stop();
-		if (revocationCheck) clearTimeout(revocationCheck);
-		for (const client of wss.clients) client.terminate();
-		await control.close();
-		await Promise.all([
-			frames.close(),
-			feeds.close(),
-			...[...running].map((cancel) => cancel())
-		]);
-		wss.close();
-		await Promise.all(servers.map((server) => new Promise((resolve) => server.close(resolve))));
-	};
-	try {
-		for (const host of options.hosts) {
-			const server = createServer((request, response) => {
-				if (localHealthRequest(request)) {
-					answerHealth(response);
-					return;
-				}
-				response.writeHead(426, { "content-type": "text/plain" }).end("stim-server speaks WebSocket only.\n");
-			});
-			server.on("upgrade", upgrade);
-			servers.push(server);
-			await new Promise((resolve, reject) => {
-				server.once("error", reject);
-				server.listen(options.port, host, () => {
-					server.off("error", reject);
-					resolve();
-				});
-			});
-			addresses.push({
-				host,
-				port: server.address().port
-			});
-		}
-	} catch (error) {
-		await close();
-		throw error;
-	}
-	return {
-		addresses,
-		close
-	};
-}
-//#endregion
-//#region bin/stim-server.ts
-const DEFAULT_PORT = 7787;
-const USAGE = `Usage:
-  stim-server [--port <n>]          serve paired clients (default port ${DEFAULT_PORT})
-  stim-server pair [--port <n>] [--control] [--json]
-                                    print a single-use pairing payload for the QR code;
-                                    --control lets the paired device run actions
-  stim-server devices [list] [--json]
-                                    list paired devices
-  stim-server devices grant <id> --control|--read
-                                    let a paired device run actions, or only read
-  stim-server devices revoke <id>   revoke a paired device
-  stim-server log [--json]          list the actions paired devices ran`;
-const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
-function fail(message) {
-	console.error(`stim-server: ${message}`);
-	process.exit(1);
-}
-function tailscaleNote(tailscale) {
-	const remedy = `Remote clients cannot connect until Tailscale runs; then restart stim-server, which prints the \`tailscale serve\` command to run once.`;
-	if (tailscale.state === "not-running") return `Tailscale is not running (${tailscale.backendState}). ${remedy}`;
-	if (tailscale.state === "unavailable") return `Tailscale is unavailable: ${tailscale.reason}. ${remedy}`;
-	return null;
-}
-function routeNote(route, port) {
-	if (route.state === "missing") return `No \`tailscale serve\` route reaches port ${port}, so phones cannot connect yet. Run this once to serve it on a tailnet-only port: \`${serveCommand(route.port, port)}\``;
-	if (route.state === "unknown") return `Could not read \`tailscale serve status --json\` (${route.reason}); assuming stim-server is served on port ${route.port}.`;
-	if (route.state === "funneled") return `Tailscale Funnel is on for port ${route.ports.join(", ")}, which proxies to stim-server, so the server is reachable from the public internet. Remove that handler (see \`tailscale serve status\`), then serve stim-server on a tailnet-only port: \`${serveCommand(route.port, port)}\``;
-	return null;
-}
-function macName(tailscale) {
-	return tailscale.state === "running" && tailscale.hostName || hostname();
-}
-async function serve(port) {
-	const login = loginShellEnvironment();
-	if (!login) console.error("stim-server: could not read the login shell environment; using this process environment.");
-	const env = { ...login ?? process.env };
-	if (!process.env.STIM_HOME && env.STIM_HOME) process.env.STIM_HOME = env.STIM_HOME;
-	if (process.env.STIM_HOME) env.STIM_HOME = process.env.STIM_HOME;
-	const tailscaleBinary = findTailscale(env);
-	const tailscale = tailscaleStatus(tailscaleBinary, env);
-	const stim = bundledStim();
-	const hosts = ["127.0.0.1", ...tailscale.state === "running" ? tailscale.ips : []];
-	let server;
-	try {
-		server = await startServer({
-			name: macName(tailscale),
-			hosts,
-			port,
-			stimCli: stim.cli,
-			stimVersion: stim.version,
-			serverVersion: pkg.version,
-			env,
-			tailscale: tailscaleBinary,
-			tailscaleState: tailscale
-		});
-	} catch (error) {
-		if (error.code === "EADDRINUSE") fail(`port ${port} is in use; another stim-server may already be running. Pass --port to use another port.`);
-		throw error;
-	}
-	console.log(`stim-server ${pkg.version} (stim ${stim.version}, protocol 1)`);
-	for (const { host, port: bound } of server.addresses) console.log(`listening on ws://${host.includes(":") ? `[${host}]` : host}:${bound}`);
-	let note = tailscaleNote(tailscale);
-	if (tailscale.state === "running" && tailscale.dnsName) {
-		const route = await serveRoute(tailscaleBinary, env, port, tailscale.ips);
-		if (route.state !== "funneled") console.log(`tailnet endpoint: ${tailnetEndpoint(tailscale.dnsName, route.port)}`);
-		note = routeNote(route, port);
-		if (route.state === "funneled") note = `${note} Pairing is refused until then.`;
-	}
-	if (note) console.error(note);
-	const shutdown = () => {
-		server.close().then(() => process.exit(0));
-	};
-	process.on("SIGINT", shutdown);
-	process.on("SIGTERM", shutdown);
-	process.on("SIGHUP", shutdown);
-}
-async function pair(port, json, control) {
-	const binary = findTailscale(process.env);
-	const tailscale = tailscaleStatus(binary, process.env);
-	let endpoint = `ws://127.0.0.1:${port}`;
-	let note = tailscaleNote(tailscale);
-	if (note) note = `${note} The endpoint above only works on this Mac.`;
-	if (tailscale.state === "running" && tailscale.dnsName) {
-		const route = await serveRoute(binary, process.env, port, tailscale.ips);
-		if (route.state === "funneled") fail(`refusing to pair. ${routeNote(route, port)}`);
-		endpoint = tailnetEndpoint(tailscale.dnsName, route.port);
-		note = routeNote(route, port);
-	}
-	const { token, expiresAt } = createPairingToken(Date.now(), capabilitiesFor(control));
-	const payload = {
-		v: 1,
-		name: macName(tailscale),
-		endpoint,
-		pairingToken: token
-	};
-	if (json) return void console.log(JSON.stringify({
-		qr: payload,
-		expiresAt
-	}));
-	console.log(JSON.stringify(payload));
-	console.error(`The pairing token is single use and expires at ${expiresAt}. The device it pairs can ${control ? "run actions" : "only read"}.`);
-	if (note) console.error(note);
-}
-function describe(device) {
-	const from = device.identity.kind === "local" ? "this Mac" : `${device.identity.nodeName || device.identity.nodeId}${device.identity.user ? ` (${device.identity.user})` : ""}`;
-	const scope = device.capabilities.includes("control") ? "control" : "read";
-	return `${device.id}  ${device.name}  ${scope}  from ${from}  paired ${device.pairedAt}  last seen ${device.lastSeenAt ?? "never"}`;
-}
-async function main() {
-	const { values, positionals } = parseArgs({
-		allowPositionals: true,
-		options: {
-			port: { type: "string" },
-			json: { type: "boolean" },
-			control: { type: "boolean" },
-			read: { type: "boolean" },
-			help: {
-				type: "boolean",
-				short: "h"
-			},
-			version: {
-				type: "boolean",
-				short: "V"
-			}
-		}
-	});
-	if (values.help) return void console.log(USAGE);
-	if (values.version) return void console.log(pkg.version);
-	const port = values.port === void 0 ? DEFAULT_PORT : Number(values.port);
-	if (!Number.isInteger(port) || port < 0 || port > 65535) fail(`--port must be a port number, got ${values.port}.`);
-	const [command, sub, arg, ...rest] = positionals;
-	if (command === void 0) return serve(port);
-	const grant = command === "devices" && sub === "grant";
-	if (values.read && !grant) fail(`--read applies only to \`devices grant\`.\n${USAGE}`);
-	if (values.control && !grant && command !== "pair") fail(`--control applies only to \`pair\` and \`devices grant\`.\n${USAGE}`);
-	if (command === "pair" && sub === void 0) return pair(port, values.json === true, values.control === true);
-	if (grant && arg !== void 0 && rest.length === 0) {
-		if (values.control === values.read) fail("devices grant takes exactly one of --control or --read.");
-		if (!grantDevice(arg, capabilitiesFor(values.control === true))) fail(`no paired device ${arg}. Run \`stim-server devices\` to list them.`);
-		console.log(`${arg} can now ${values.control ? "run actions" : "only read"}.`);
-		return;
-	}
-	if (command === "log" && sub === void 0) {
-		const records = readAudit();
-		if (values.json) return void console.log(JSON.stringify({ actions: records }));
-		if (!records.length) console.log("No actions.");
-		for (const record of records) {
-			const outcome = record.ok ? `ok${record.reason ? ` (${record.reason})` : ""}` : `${record.error?.code ?? "failed"}: ${record.error?.message ?? ""}`;
-			const line = `${record.at}  ${record.device.id} (${record.device.name})  ${record.action}  ${record.workspace}  ${outcome}`;
-			console.log(Array.from(line, (char) => /\p{Cc}/u.test(char) ? "?" : char).join(""));
-		}
-		return;
-	}
-	if (command === "devices" && (sub === void 0 || sub === "list") && arg === void 0) {
-		const devices = readDevices();
-		if (values.json) {
-			const listed = devices.map(({ id, name, identity, pairedAt, lastSeenAt, capabilities }) => ({
-				id,
-				name,
-				identity,
-				pairedAt,
-				lastSeenAt,
-				capabilities
-			}));
-			console.log(JSON.stringify({ devices: listed }));
-			return;
-		}
-		if (!devices.length) console.log("No paired devices.");
-		for (const device of devices) console.log(describe(device));
-		return;
-	}
-	if (command === "devices" && sub === "revoke" && arg !== void 0 && rest.length === 0) {
-		if (!revokeDevice(arg)) fail(`no paired device ${arg}. Run \`stim-server devices\` to list them.`);
-		console.log(`Revoked ${arg}.`);
-		return;
-	}
-	fail(`unknown command.\n${USAGE}`);
-}
-await main();
+//#region bin/node-check.ts
+const encode = (version) => version.split(".", 3).reduce((sum, part) => sum * 1e3 + parseInt(part, 10), 0);
+if (encode(process.versions.node) < encode("22.12.0")) {
+	process.stderr.write(`STIM_NODE_UNSUPPORTED: stim-server needs Node 22.12.0 or later; this is Node ${process.versions.node} at ${process.execPath}. To run stim-server where a project pins an older Node, see https://stim.appandflow.com/docs/requirements#older-node-pins\n`);
+	process.exitCode = 1;
+} else import("./stim-server-OiJI9xLU.mjs");
 //#endregion
 export {};