stim 1.14.0 → 1.16.0

package/dist/idle-shutdown-CTsDnAde.mjs

@@ -0,0 +1,122 @@
+import { R as deviceSlotKey, _ as loadConfig$1 } from "./config-D0DbpZtM.mjs";
+import { o as formatLongDuration } from "./command-output-DnJMdEY-.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-B8-aJ1_5.mjs";
+import { o as canonicalPath } from "./in-use-DvBw0Kxo.mjs";
+import { n as collectOwnedDeviceActivity, s as workspaceBuildInProgress } from "./idle-DYVymG92.mjs";
+import { u as listAllIosSims } from "./ios-BaInn3sW.mjs";
+import { i as teardownOwnedAvd, o as teardownOwnedIosSim } from "./teardown-CL6vDs2Y.mjs";
+import { DEVICE_IDLE_SHUTDOWN_KEY, readDeviceIdleShutdowns } from "@stim-cli/core/state";
+//#region src/devices/idle-shutdown.ts
+const SIM_LIST_TIMEOUT_MS = 1e4;
+const MINUTE_MS = 6e4;
+/**
+* How long a booted owned device has been idle, when that is at least `idleMs` and nothing keeps it in use: no
+* driver, Stim or agent-device lock, or unreadable activity evidence, no build in the workspace, and no activity
+* (including an open stim-server viewer) for `idleMs`. Null keeps the device running.
+*/
+function idleShutdownDueMs(activity, { idleMs, now, buildInProgress, platform = process.platform }) {
+	if (buildInProgress || activity.state === "driven") return null;
+	const unknown = platform === "win32" ? activity.basis.filter((basis) => basis !== "driver-process") : activity.basis;
+	if (activity.state === "unknown" && unknown.length > 0) return null;
+	const last = Date.parse(activity.lastActivityAt ?? "");
+	if (!Number.isFinite(last)) return null;
+	const idle = now - last;
+	return idle >= idleMs ? idle : null;
+}
+function listSims() {
+	try {
+		return listAllIosSims({ timeoutMs: SIM_LIST_TIMEOUT_MS });
+	} catch {
+		return [];
+	}
+}
+/** The workspace's booted owned simulators and emulators that have been idle for `idleMs` or more. */
+function dueIdleDevices(root, idleMs, now = Date.now()) {
+	const config = loadConfig$1();
+	const self = canonicalPath(root);
+	const entry = Object.entries(config?.projects ?? {}).find(([path]) => canonicalPath(path) === self);
+	if (!config || !entry) return [];
+	const buildInProgress = workspaceBuildInProgress(entry[0]);
+	return collectOwnedDeviceActivity({
+		...config,
+		projects: { [entry[0]]: entry[1] }
+	}, listSims(), now).flatMap((device) => {
+		const idleForMs = idleShutdownDueMs(device.activity, {
+			idleMs,
+			now,
+			buildInProgress
+		});
+		return idleForMs === null ? [] : [{
+			device,
+			idleForMs
+		}];
+	});
+}
+/**
+* Shuts down, through centralized teardown, each of the workspace's owned devices that is still idle for `idleMs`,
+* and records why. The caller holds the workspace's native-run lock, so no `ios` or `android` run is booting or
+* installing on them.
+*/
+function shutDownIdleDevices(root, idleMs, log, now = Date.now()) {
+	let shutDown = 0;
+	for (const { device, idleForMs } of dueIdleDevices(root, idleMs, now)) {
+		const what = `${device.kind === "ios" ? "simulator" : "emulator"} ${device.name}`;
+		const outcome = device.kind === "ios" ? teardownOwnedIosSim(device.id, {
+			label: device.name,
+			workspace: root
+		}) : teardownOwnedAvd(device.id, {
+			owner: {
+				projectPath: device.project,
+				slot: device.slot
+			},
+			workspace: root
+		});
+		if (outcome.status === "torn-down") {
+			shutDown++;
+			const idleMinutes = Math.floor(idleForMs / MINUTE_MS);
+			try {
+				updateWorkspaceState(root, (state) => ({
+					...state,
+					[DEVICE_IDLE_SHUTDOWN_KEY]: {
+						...readDeviceIdleShutdowns(state),
+						[deviceSlotKey(device.kind, device.slot)]: {
+							at: new Date(now).toISOString(),
+							idleMinutes
+						}
+					}
+				}));
+			} catch (error) {
+				log({
+					level: "warn",
+					event: "device_idle_shutdown_failed",
+					msg: `shut down idle ${what} but could not record it: ${error?.message || error}`
+				});
+			}
+			log({
+				level: "info",
+				event: "device_idle_shutdown",
+				msg: `shut down ${what}, idle ${formatLongDuration(idleForMs)}`
+			});
+		} else if (outcome.status !== "missing") log({
+			level: "warn",
+			event: "device_idle_shutdown_failed",
+			msg: `could not shut down idle ${what}: ${outcome.reason}`
+		});
+	}
+	return shutDown;
+}
+/** Forgets the slot's idle shutdown once a run boots its device again. */
+function clearDeviceIdleShutdown(root, platform, slot = "default") {
+	const key = deviceSlotKey(platform, slot);
+	if (!(key in readDeviceIdleShutdowns(readWorkspaceState$1(root)))) return;
+	updateWorkspaceState(root, (state) => {
+		const { [key]: _cleared, ...rest } = readDeviceIdleShutdowns(state);
+		const { [DEVICE_IDLE_SHUTDOWN_KEY]: _all, ...others } = state;
+		return Object.keys(rest).length ? {
+			...others,
+			[DEVICE_IDLE_SHUTDOWN_KEY]: rest
+		} : others;
+	});
+}
+//#endregion
+export { dueIdleDevices as n, shutDownIdleDevices as r, clearDeviceIdleShutdown as t };

package/dist/in-use-DvBw0Kxo.mjs

@@ -0,0 +1,130 @@
+import { p as getProject } from "./config-D0DbpZtM.mjs";
+import { n as ownership_claim_exports } from "./process-identity-BmRm1qV0.mjs";
+import { r as readWorkspaceState$1, v as workspaceDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { o as readWebRecord, u as webFacts } from "./state-C1jB7Q8q.mjs";
+import { h as listBuildLocks } from "./device-lease-D-hLqx1b.mjs";
+import { n as listBuildSlots } from "./build-slots-rUk77xqh.mjs";
+import { n as workspaceProcessLockError, r as workspaceProcessLockPath, t as withWorkspaceProcessLock } from "./workspace-process-lock-BL7Q0HCO.mjs";
+import { i as macosRuntimeClaim } from "./state-3DwSQIBK.mjs";
+import { n as managedLockHolders, t as resolveSupervisorTarget } from "./ownership-hCkPzGmr.mjs";
+import { lstatSync, readdirSync, rmSync, rmdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { realpathSync as realpathSync$1 } from "fs";
+import { resolve as resolve$1 } from "path";
+import { hostedIosRecords, macosAppState, parseHostedIosPlacement, readMacosRecord, unreadableHostedIos } from "@stim-cli/core/state";
+//#region src/commands/gc/paths.ts
+function canonicalPath(p) {
+	try {
+		return realpathSync$1(p);
+	} catch {
+		return resolve$1(p);
+	}
+}
+//#endregion
+//#region src/commands/gc/results.ts
+const results = [];
+function recordGcResult(kind, status, label, { id = null, bytes = null, detail = null } = {}) {
+	results.push({
+		kind,
+		status,
+		label,
+		id,
+		bytes,
+		detail
+	});
+}
+function takeGcResults() {
+	return results.splice(0);
+}
+//#endregion
+//#region src/workspace/in-use.ts
+const NATIVE_RUN = "native-run";
+const NATIVE_RUN_HELD = "a stim ios, android or stop run holds its native-run.lock";
+function workspaceInUse(root, { supervisor = true, managedLocks = true, hosted = true, nativeRun = true } = {}) {
+	const reasons = [];
+	if (supervisor) {
+		const project = getProject(root);
+		const target = resolveSupervisorTarget({
+			state: readWorkspaceState$1(root)?.supervisor,
+			record: project?.supervisor,
+			reservedPort: project?.metroPort
+		});
+		if (target.status === "ours") reasons.push(`its dev server supervisor (pid ${target.pid}) is running`);
+		else if (target.status === "unverified") reasons.push(`its dev server supervisor cannot be verified: ${target.reason ?? "unknown identity"}`);
+		const macos = macosAppState(readMacosRecord(root));
+		if (macos?.host) reasons.push(`its macOS app runs on ${macos.host.machine}`);
+		else if (macos?.state === "running" || macos?.state === "orphaned" || macos?.build.state === "running") reasons.push("its macOS app or build is running");
+		else if (macos?.state === "unverified" || !macos && readWorkspaceState$1(root)?.macos !== void 0) reasons.push("its macOS process owner cannot be verified");
+		const runtime = (0, ownership_claim_exports.readClaimSet)(macosRuntimeClaim(root));
+		if (runtime.live.length) reasons.push("its macOS runtime claim is held");
+		else if (runtime.unresolved[0]) reasons.push(`its macOS runtime cannot be verified: ${runtime.unresolved[0].reason}`);
+		const browser = webFacts(readWebRecord(root));
+		if (browser?.status === "running" || browser?.status === "orphaned") reasons.push(`its owned Chrome (pid ${browser.record.chromeProcess?.pid}) is running`);
+		else if (browser?.status === "unverified") reasons.push("its owned Chrome cannot be verified");
+	}
+	if (nativeRun) {
+		const claims = (0, ownership_claim_exports.readClaimSet)(workspaceProcessLockPath(workspaceDir(root), NATIVE_RUN, true));
+		if (claims.live.length) reasons.push(NATIVE_RUN_HELD);
+		else if (claims.unresolved[0]) reasons.push(`its native-run.lock cannot be resolved: ${claims.unresolved[0].reason}`);
+	}
+	for (const [slot, record] of Object.entries(hosted ? hostedIosRecords(readWorkspaceState$1(root)) : {})) {
+		const placement = parseHostedIosPlacement(record);
+		reasons.push(placement ? `its iOS simulator runs on ${placement.machine}` : unreadableHostedIos(slot));
+	}
+	const self = canonicalPath(root);
+	for (const [kind, entries] of [["build lock", listBuildLocks()], ["build slot", listBuildSlots()]]) for (const entry of entries) {
+		if (!entry.alive && !entry.unresolved) continue;
+		if (entry.projectRoot !== null && canonicalPath(entry.projectRoot) === self) reasons.push(`a ${entry.alive ? "live" : "unresolvable"} ${kind} at ${entry.path} names it`);
+	}
+	if (managedLocks) reasons.push(...managedLockHolders(root));
+	return reasons;
+}
+function emptyWorkspaceDir(dir) {
+	if (lstatSync(dir).isSymbolicLink()) {
+		unlinkSync(dir);
+		return;
+	}
+	for (const name of readdirSync(dir)) if (name !== `${NATIVE_RUN}.lock`) rmSync(join(dir, name), {
+		recursive: true,
+		force: true
+	});
+}
+async function withIdleWorkspace(root, fn, { purpose, ...checks }) {
+	try {
+		return await withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN, async () => {
+			const reasons = workspaceInUse(root, {
+				...checks,
+				nativeRun: false
+			});
+			if (reasons.length) return {
+				ran: false,
+				reasons
+			};
+			return {
+				ran: true,
+				value: await fn()
+			};
+		}, {
+			external: true,
+			waitMs: 0,
+			ownerPurpose: purpose
+		});
+	} catch (error) {
+		if (workspaceProcessLockError(error)) return {
+			ran: false,
+			reasons: [NATIVE_RUN_HELD]
+		};
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return {
+			ran: false,
+			reasons: [`its native-run.lock cannot be taken: ${error.reason}`]
+		};
+		throw error;
+	} finally {
+		try {
+			const dir = workspaceDir(root);
+			if (!lstatSync(dir).isSymbolicLink()) rmdirSync(dir);
+		} catch {}
+	}
+}
+//#endregion
+export { takeGcResults as a, recordGcResult as i, withIdleWorkspace as n, canonicalPath as o, workspaceInUse as r, emptyWorkspaceDir as t };

package/dist/{ios-BwDPrnYQ.mjs → ios-BaInn3sW.mjs}

@@ -1,13 +1,144 @@
-import { _ as loadConfig$1 } from "./config-lvc7d3C2.mjs";
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { _ as loadConfig$1 } from "./config-D0DbpZtM.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { n as settingDefault, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-CXt8-Z3J.mjs";
-import { nt as isStimOwnedSim } from "./android-d6rGq1pA.mjs";
-import { r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-CllH_8eb.mjs";
-import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-D5owjN4C.mjs";
+import { at as isStimOwnedSim } from "./android-B_NumVyQ.mjs";
+import { n as settingDefault, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-Cnz8CPnl.mjs";
+import { createHash } from "node:crypto";
+import { closeSync, existsSync, lstatSync, mkdtempSync, openSync, readSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
 import { IOS_SIMULATOR_APPS, settingDefinition } from "@stim-cli/core/state";
-import { dirname, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
+//#region src/engine/installed-artifact.ts
+const READ_CHUNK_BYTES = 1048576;
+const DEVICE_PATH_TIMEOUT_MS = 3e4;
+const DEVICE_HASH_TIMEOUT_MS = 12e4;
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+function parseInstalledApkPath(text) {
+	if (typeof text !== "string") return null;
+	const paths = [];
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line.startsWith("package:")) continue;
+		const path = line.slice(8);
+		if (path.startsWith("/")) paths.push(path);
+	}
+	return paths.length === 1 ? paths[0] : null;
+}
+function parseDeviceSha256(text) {
+	if (typeof text !== "string") return null;
+	const first = text.trim().split(/\s+/)[0] ?? "";
+	return SHA256_HEX.test(first) ? first : null;
+}
+function parseAppContainerPath(text) {
+	if (typeof text !== "string") return null;
+	const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+	return lines.length === 1 && isAbsolute(lines[0]) ? lines[0] : null;
+}
+function artifactsMatch(local, installed) {
+	return Boolean(local) && local === installed;
+}
+function hashFile(file) {
+	let fd = null;
+	try {
+		fd = openSync(file, "r");
+		const digest = createHash("sha256");
+		const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+		for (;;) {
+			const read = readSync(fd, buffer, 0, READ_CHUNK_BYTES, null);
+			if (read <= 0) break;
+			digest.update(buffer.subarray(0, read));
+		}
+		return digest.digest("hex");
+	} catch {
+		return null;
+	} finally {
+		if (fd !== null) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+function hashBundle(dir) {
+	const digest = createHash("sha256");
+	const walk = (abs, rel) => {
+		let names;
+		try {
+			names = readdirSync(abs);
+		} catch {
+			return false;
+		}
+		for (const name of names.toSorted()) {
+			const child = join(abs, name);
+			const path = rel === "" ? name : `${rel}/${name}`;
+			let stat;
+			try {
+				stat = lstatSync(child);
+			} catch {
+				return false;
+			}
+			if (stat.isDirectory()) {
+				if (!walk(child, path)) return false;
+				continue;
+			}
+			if (!stat.isFile()) return false;
+			const file = hashFile(child);
+			if (file === null) return false;
+			digest.update(`${path}\0${file}\n`);
+		}
+		return true;
+	};
+	return walk(dir, "") ? digest.digest("hex") : null;
+}
+function deviceHoldsApk({ serial, packageName, apkPath }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let path;
+	try {
+		path = parseInstalledApkPath(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"pm",
+			"path",
+			packageName
+		], { timeoutMs: DEVICE_PATH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!path) return false;
+	let installed;
+	try {
+		installed = parseDeviceSha256(e.runFile("adb", [
+			"-s",
+			serial,
+			"shell",
+			"sha256sum",
+			path
+		], { timeoutMs: DEVICE_HASH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!installed) return false;
+	return artifactsMatch(hashFile(apkPath), installed);
+}
+function deviceHoldsBundle({ udid, bundleId, appPath }, { exec = null } = {}) {
+	const e = exec || getExecutor();
+	let container;
+	try {
+		container = parseAppContainerPath(e.runFile("xcrun", [
+			"simctl",
+			"get_app_container",
+			udid,
+			bundleId
+		], { timeoutMs: DEVICE_PATH_TIMEOUT_MS }));
+	} catch {
+		return false;
+	}
+	if (!container) return false;
+	const installed = hashBundle(container);
+	if (!installed) return false;
+	return artifactsMatch(hashBundle(appPath), installed);
+}
+//#endregion
 //#region src/host-memory.ts
 function readHostMemoryPressure(exec = getExecutor(), platform = process.platform) {
 	if (platform !== "darwin") return null;
@@ -201,7 +332,7 @@ async function awaitBootCommand(args, attemptMs, onLine) {
 	const detail = lines.length ? `: ${lines.join(" | ")}` : "";
 	throw new Error(`${command} failed with exit code ${result.code ?? "unknown"}${detail}`);
 }
-async function bootIosSim(udid, { timeoutMs = IOS_BOOT_TIMEOUT_MS, attemptMs = BOOTSTATUS_ATTEMPT_MS, simulatorApp, label = udid, out = () => {} } = {}) {
+async function bootIosSim(udid, { timeoutMs = IOS_BOOT_TIMEOUT_MS, attemptMs = BOOTSTATUS_ATTEMPT_MS, simulatorApp, openViewer = true, label = udid, out = () => {} } = {}) {
 	const exec = getExecutor();
 	const viewer = configuredIosSimulatorViewer(simulatorApp);
 	const started = Date.now();
@@ -280,7 +411,7 @@ async function bootIosSim(udid, { timeoutMs = IOS_BOOT_TIMEOUT_MS, attemptMs = B
 	} finally {
 		clearInterval(monitor);
 	}
-	viewer.open(udid);
+	if (openViewer) viewer.open(udid);
 }
 function shutdownIosSim(udid) {
 	getExecutor().runQuiet(`xcrun simctl shutdown ${udid}`, SIMCTL_OPTIONS);
@@ -432,6 +563,66 @@ function resetIosKeychain(udid) {
 		"reset"
 	], SIMCTL_OPTIONS);
 }
+const CLEARED_CONTAINER_DIRS = [
+	"Documents",
+	"Library",
+	"tmp",
+	"SystemData"
+];
+function clearIosAppData(udid, bundleId, { defaultsPlist = null } = {}) {
+	const exec = getExecutor();
+	if (defaultsPlist) exec.runFile("xcrun", [
+		"simctl",
+		"spawn",
+		udid,
+		"defaults",
+		"import",
+		bundleId,
+		"-"
+	], {
+		...SIMCTL_OPTIONS,
+		input: defaultsPlist
+	});
+	else try {
+		exec.runFile("xcrun", [
+			"simctl",
+			"spawn",
+			udid,
+			"defaults",
+			"delete",
+			bundleId
+		], SIMCTL_OPTIONS);
+	} catch (error) {
+		if (!/Domain .* not found/.test(String(error?.message))) throw error;
+	}
+	const output = exec.runFile("xcrun", [
+		"simctl",
+		"get_app_container",
+		udid,
+		bundleId,
+		"data"
+	], SIMCTL_OPTIONS);
+	const container = parseAppContainerPath(output);
+	if (!container) throw new Error(`simctl get_app_container returned no data container for ${bundleId}: ${JSON.stringify(output)}`);
+	for (const name of CLEARED_CONTAINER_DIRS) {
+		const dir = join(container, name);
+		let stat;
+		try {
+			stat = lstatSync(dir);
+		} catch (error) {
+			if (error?.code === "ENOENT") continue;
+			throw error;
+		}
+		if (!stat.isDirectory()) {
+			rmSync(dir, { force: true });
+			continue;
+		}
+		for (const child of readdirSync(dir)) rmSync(join(dir, child), {
+			recursive: true,
+			force: true
+		});
+	}
+}
 function uninstallIosApp(udid, bundleId) {
 	getExecutor().runFile("xcrun", [
 		"simctl",
@@ -526,4 +717,4 @@ function listIosRuntimes() {
 	}));
 }
 //#endregion
-export { sanitizeDeviceLabel as C, parseIosSimulatorApp as D, configuredIosSimulatorViewer as E, hostMemoryPressureAdvice as O, resolveOwnedIosSim as S, uninstallIosApp as T, parseSimctlList as _, deleteParkedIosSim as a, resetIosPrivacy as b, iosSimulatorFailureAdvice as c, listIosDeviceTypes as d, listIosRuntimes as f, parseRuntimeVersion as g, parkedSimName as h, deleteIosSim as i, readHostMemoryPressure as k, listAllIosSims as l, ownedSimName as m, bootIosSim as n, eraseIosSim as o, listUserApps as p, createOwnedIosSim as r, iosRuntimeMatches as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSimsAsync as u, renameIosSim as v, shutdownIosSim as w, resolveIosCreation as x, resetIosKeychain as y };
+export { hostMemoryPressureAdvice as A, resolveIosCreation as C, uninstallIosApp as D, shutdownIosSim as E, deviceHoldsApk as M, deviceHoldsBundle as N, configuredIosSimulatorViewer as O, resetIosPrivacy as S, sanitizeDeviceLabel as T, parseRuntimeVersion as _, deleteIosSim as a, renameIosSim as b, iosRuntimeMatches as c, listAllIosSimsAsync as d, listIosDeviceTypes as f, parkedSimName as g, ownedSimName as h, createOwnedIosSim as i, readHostMemoryPressure as j, parseIosSimulatorApp as k, iosSimulatorFailureAdvice as l, listUserApps as m, bootIosSim as n, deleteParkedIosSim as o, listIosRuntimes as p, clearIosAppData as r, eraseIosSim as s, IOS_BOOT_TIMEOUT_MS as t, listAllIosSims as u, parseSimctlList as v, resolveOwnedIosSim as w, resetIosKeychain as x, pickDefaultIosCreation as y };

package/dist/ios-Cr1h5gnO.mjs

@@ -0,0 +1,189 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+//#region src/collector/ios.ts
+const MESSAGE_TYPE_LEVEL = {
+	Debug: "debug",
+	Info: "info",
+	Default: "info",
+	Error: "error",
+	Fault: "fatal"
+};
+function levelFromMessageType(messageType) {
+	return MESSAGE_TYPE_LEVEL[messageType] ?? "info";
+}
+const NOISE_RULES = [
+	{
+		id: "network",
+		subsystem: "com.apple.network"
+	},
+	{
+		id: "network-default-subsystem",
+		messagePrefix: [
+			"nw_socket",
+			"nw_connection",
+			"nw_protocol",
+			"nw_endpoint",
+			"nw_path",
+			"nw_resolver",
+			"nw_flow",
+			"nw_read_request",
+			"nw_write_request",
+			"tcp_input"
+		]
+	},
+	{
+		id: "sectrust",
+		subsystem: "com.apple.securityd"
+	},
+	{
+		id: "sectrust-default-subsystem",
+		messagePrefix: [
+			"SecTrust",
+			"SecOSStatus",
+			"TrustResultType"
+		]
+	},
+	{
+		id: "webkit",
+		subsystem: "com.apple.WebKit"
+	},
+	{
+		id: "webkit-default-subsystem",
+		messagePrefix: [
+			"WebPrivacy",
+			"GPUProcessProxy",
+			"WebProcessProxy"
+		]
+	},
+	{
+		id: "audio-factory",
+		messageIncludes: ["AddInstanceForFactory"]
+	},
+	{
+		id: "coreui",
+		subsystem: "com.apple.coreui"
+	},
+	{
+		id: "coreui-default-subsystem",
+		messagePrefix: [
+			"CUICatalog:",
+			"CoreUI:",
+			"CoreThemeDefinition"
+		]
+	},
+	{
+		id: "uiscene-deprecation",
+		messageIncludes: [
+			"UIScene lifecycle will soon be required",
+			"`UIScene` lifecycle will soon be required",
+			"must migrate to UIScene",
+			"migrate to UIScene lifecycle"
+		]
+	},
+	{
+		id: "react-native-focus-cache",
+		exactSubsystem: "com.apple.UIKit",
+		category: "UIFocus",
+		messageEquals: "RCTScrollViewComponentView implements focusItemsInRect: - caching for linear focus movement is limited as long as this view is on screen."
+	},
+	{
+		id: "cfnetwork-performance-diagnostic",
+		exactSubsystem: "com.apple.runtime-issues",
+		category: "CFNetwork Performance Diagnostic",
+		level: "warn"
+	}
+];
+function ruleMatches(rule, { subsystem, category, message }) {
+	if (rule.subsystem && subsystem !== rule.subsystem && !subsystem.startsWith(`${rule.subsystem}.`)) return false;
+	if (rule.exactSubsystem && subsystem !== rule.exactSubsystem) return false;
+	if (rule.category && category !== rule.category) return false;
+	if (rule.messageEquals && message !== rule.messageEquals) return false;
+	if (rule.messagePrefix && !rule.messagePrefix.some((p) => message.startsWith(p))) return false;
+	if (rule.messageIncludes && !rule.messageIncludes.some((p) => message.includes(p))) return false;
+	return true;
+}
+function matchingNoiseRule(event) {
+	const subsystem = typeof event?.subsystem === "string" ? event.subsystem : "";
+	const category = typeof event?.category === "string" ? event.category : "";
+	const message = typeof event?.eventMessage === "string" ? event.eventMessage : "";
+	return NOISE_RULES.find((rule) => ruleMatches(rule, {
+		subsystem,
+		category,
+		message
+	}));
+}
+function levelForEvent(event) {
+	const level = levelFromMessageType(event?.messageType);
+	if (level !== "error" && level !== "fatal") return level;
+	const rule = matchingNoiseRule(event);
+	return rule ? rule.level ?? "info" : level;
+}
+function procFromImagePath(path) {
+	if (typeof path !== "string" || !path) return null;
+	const parts = path.split("/");
+	return parts[parts.length - 1] || null;
+}
+function tsFromEvent(event, now = Date.now) {
+	const parsed = Date.parse(event?.timestamp);
+	return Number.isFinite(parsed) ? parsed : now();
+}
+function recordFromLogEvent(event, { now = Date.now } = {}) {
+	if (!event || typeof event !== "object") return null;
+	const eventType = event.eventType;
+	if (eventType && eventType !== "logEvent") return null;
+	const msg = typeof event.eventMessage === "string" ? event.eventMessage : "";
+	if (!msg.trim()) return null;
+	const record = {
+		ts: tsFromEvent(event, now),
+		src: "device",
+		level: levelForEvent(event),
+		msg
+	};
+	const proc = procFromImagePath(event.processImagePath);
+	if (proc) record.proc = proc;
+	if (typeof event.subsystem === "string") record.subsystem = event.subsystem;
+	if (typeof event.category === "string") record.category = event.category;
+	return record;
+}
+function parseLogStreamLine(line, { now = Date.now } = {}) {
+	if (typeof line !== "string") return null;
+	const trimmed = line.trim();
+	if (!trimmed || trimmed[0] !== "{") return null;
+	let event;
+	try {
+		event = JSON.parse(trimmed);
+	} catch {
+		return null;
+	}
+	return recordFromLogEvent(event, { now });
+}
+function logStreamArgs(udid, appName, executableName) {
+	return [
+		"simctl",
+		"spawn",
+		udid,
+		"log",
+		"stream",
+		"--style",
+		"ndjson",
+		"--predicate",
+		`processImagePath ENDSWITH "/${appName}.app/${executableName && executableName.trim() !== "" ? executableName.trim() : appName}"`,
+		"--level",
+		"info"
+	];
+}
+function appNameFromBundleId(bundleId) {
+	const parts = String(bundleId || "").split(".");
+	return parts[parts.length - 1] || String(bundleId || "");
+}
+function startIosLogStream({ udid, appName, executableName = null, spawnFn = null }) {
+	return (spawnFn || ((cmd, args, opts) => getExecutor().spawn(cmd, args, opts)))("xcrun", logStreamArgs(udid, appName, executableName), {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: false
+	});
+}
+//#endregion
+export { parseLogStreamLine as n, startIosLogStream as r, appNameFromBundleId as t };