stim 1.17.2 → 1.19.0

package/dist/{android-B_YNZy61.mjs → android-BdQC6zs1.mjs}

@@ -1,16 +1,16 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { C as saveConfig, D as withConfigLock$1, H as projectDeviceSlots, I as assignSlotDevice, U as removeSlotDevice, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1, z as deviceSlotPlatforms } from "./config-D0DbpZtM.mjs";
-import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-BmRm1qV0.mjs";
-import { s as androidDataPartitionSizeBytes } from "./settings-Cfd-0r2d.mjs";
-import { o as pidExists, u as signalProcessTree } from "./metro-g8NqiJp-.mjs";
-import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-CpvzBL25.mjs";
-import { n as settingDefault, r as stimDesktopInstalled, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-Cnz8CPnl.mjs";
+import { n as ownership_claim_exports, t as process_identity_exports } from "./process-identity-Biv3arCO.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { C as saveConfig, D as withConfigLock$1, H as projectDeviceSlots, I as assignSlotDevice, U as removeSlotDevice, _ as loadConfig$1, c as ensureConfig, d as getConfigDir, f as getConfigPath$1, z as deviceSlotPlatforms } from "./config-DC5jEtd1.mjs";
+import { s as androidDataPartitionSizeBytes } from "./settings-CxgngUZk.mjs";
+import { d as signalProcessTree, s as pidExists } from "./metro-DI2AjPF_.mjs";
+import { n as readCreatedDevices$1, r as recordCreatedDevice, t as forgetCreatedDevice } from "./created-devices-D0s26Hx5.mjs";
+import { n as settingDefault, r as stimDesktopInstalled, t as STIM_DESKTOP_OPEN_OPTIONS } from "./stim-desktop-C65jk_q2.mjs";
 import { join } from "node:path";
-import { existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
-import { homedir, tmpdir } from "os";
 import { dirname as dirname$1, isAbsolute as isAbsolute$1, join as join$1, resolve as resolve$1 } from "path";
 import { ANDROID_EMULATOR_APPS, getParkedMax, loadConfig, settingDefinition } from "@stim-cli/core/state";
 import { isDeepStrictEqual } from "node:util";
+import { existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
 //#region src/devices/sim-pool.ts
 const POOL_SETTING_REMEDY = "Run `stim guide settings` for the device pool bounds and where it can be set.";
 function parkedMaxSetting(platform, options = {}) {

package/dist/android-BvV1gGdN.mjs

@@ -0,0 +1,4 @@
+import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-Bt8ygHE7.mjs";
+import { a as collectorLogFile, c as androidFacts, i as runAndroidOperation, l as lastBuildRecord, n as registerAndroid, o as killPreviousCollector, r as runAndroid, s as startCollector, t as androidCommand } from "./android-BXc6BmEi.mjs";
+import { C as resolveSystemImage, _ as isReleaseVariant, c as androidSystemImageSetting, d as apkPackage, h as findAapt, i as NO_FINGERPRINT, l as androidVariantSetting, m as dumpApkManifest, p as displayPath, r as NO_DEVICE, s as androidDevClientScheme, u as apkDevClientFacts, v as noDeviceDiagnostic, w as resolveVariant, y as parseXmltree } from "./support-DsNaFg6D.mjs";
+export { NO_DEVICE, NO_FINGERPRINT, androidDevClientScheme, androidFacts, androidSystemImageSetting, androidVariantSetting, apkDevClientFacts, apkPackage, collectorLogFile, androidCommand as default, displayPath, dumpApkManifest, findAapt, formatDuration, isReleaseVariant, killPreviousCollector, lastBuildRecord, noDeviceDiagnostic, parseXmltree, phaseLine, registerAndroid, resolveSystemImage, resolveVariant, runAndroid, runAndroidOperation, shortHash, startCollector };

package/dist/{android-DE4v59Mb.mjs → android-DE5g_5gv.mjs}

@@ -1,5 +1,5 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { u as androidToolCwd } from "./android-B_YNZy61.mjs";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { u as androidToolCwd } from "./android-BdQC6zs1.mjs";
 //#region src/collector/android.ts
 const LEVEL_BY_LETTER = {
 	V: "debug",

package/dist/{android-cas-ZFpjJBL_.mjs → android-cas-C87geAg-.mjs}

@@ -1,12 +1,12 @@
-import { d as getConfigDir } from "./config-D0DbpZtM.mjs";
-import { r as register } from "./cache-manifest-DnUHBJaU.mjs";
-import { u as ensureWorkspaceStorage, w as withDirLock$1 } from "./workspace-state-DqcCbpE7.mjs";
-import { createHash, randomUUID } from "node:crypto";
+import { d as getConfigDir } from "./config-DC5jEtd1.mjs";
+import { u as ensureWorkspaceStorage, w as withDirLock$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { r as register } from "./cache-manifest-DiwKSyv9.mjs";
 import { accessSync, constants, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { quotedPath } from "@stim-cli/core";
 import { isJsonObject, readJsonFile } from "@stim-cli/core/state";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { quotedPath } from "@stim-cli/core";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/engine/android-cas.ts
 const CAS_TOOLCHAIN_FIELDS = [
 	"clang",

package/dist/android-cas-compiler.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { createHash, randomUUID } from "node:crypto";
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
 import { once } from "node:events";
 //#region bin/android-cas-compiler.ts
 const context = process.env.STIM_ANDROID_CAS_CONTEXT;

package/dist/api-DIf_s86s.mjs

@@ -0,0 +1,150 @@
+import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as spawnEntry } from "./spawn-entry-Dcb7sDUz.mjs";
+import { realpathSync } from "node:fs";
+import { isAbsolute } from "node:path";
+//#region src/api.ts
+var StimError = class extends Error {
+	code;
+	remedy;
+	details;
+	constructor({ code, message, remedy = null, details }) {
+		super(message);
+		this.name = "StimError";
+		this.code = code;
+		this.remedy = remedy;
+		this.details = details;
+	}
+};
+/**
+* Creates a client without starting processes or changing the caller's cwd, environment, or signal handlers.
+* Each operation runs in a separate Stim worker. Resources remain workspace-owned until stop() is called.
+*/
+function createStim(options) {
+	let projectRoot;
+	try {
+		projectRoot = realpathSync(options.projectRoot);
+	} catch (error) {
+		throw new StimError({
+			code: "STIM_NO_PROJECT",
+			message: `Could not resolve projectRoot ${options.projectRoot}: ${error instanceof Error ? error.message : String(error)}`,
+			remedy: "Pass the path to an existing, readable app directory."
+		});
+	}
+	for (const [name, path] of [["home", options.home], ["buildCache", options.buildCache]]) if (path !== void 0 && !isAbsolute(path)) throw new StimError({
+		code: "STIM_BAD_ARG",
+		message: `${name} must be an absolute path.`
+	});
+	const context = {
+		...options,
+		projectRoot,
+		env: {
+			...process.env,
+			...options.home === void 0 ? {} : { STIM_HOME: options.home },
+			...options.buildCache === void 0 ? {} : { STIM_BUILD_CACHE: options.buildCache },
+			FORCE_COLOR: "0"
+		}
+	};
+	return {
+		projectRoot,
+		run: (({ signal, ...request }) => invoke(context, {
+			operation: "run",
+			options: request
+		}, signal)),
+		stop({ signal, ...request } = {}) {
+			return invoke(context, {
+				operation: "stop",
+				options: request
+			}, signal);
+		},
+		diagnostics({ signal, ...request } = {}) {
+			if (request.tail !== void 0 && (!Number.isSafeInteger(request.tail) || request.tail < 0)) return Promise.reject(new StimError({
+				code: "STIM_BAD_ARG",
+				message: "tail must be a non-negative integer."
+			}));
+			return invoke(context, {
+				operation: "diagnostics",
+				options: request
+			}, signal);
+		}
+	};
+}
+function cancelled() {
+	return new StimError({
+		code: "STIM_CANCELLED",
+		message: "The Stim operation was cancelled."
+	});
+}
+function invoke(context, request, signal) {
+	if (signal?.aborted) return Promise.reject(cancelled());
+	return new Promise((resolve, reject) => {
+		const child = getExecutor().spawn(process.execPath, [spawnEntry("api-run")], {
+			cwd: context.projectRoot,
+			env: context.env,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		let response;
+		let transportError;
+		let callbackError;
+		let callbackFailed = false;
+		let stderr = "";
+		const abort = () => {
+			child.send?.({ operation: "cancel" }, (error) => {
+				if (error) child.kill("SIGINT");
+			});
+		};
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) abort();
+		const progress = (stream, message) => {
+			if (stream === "stderr") stderr = (stderr + message).slice(-16384);
+			if (!context.onProgress || callbackFailed) return;
+			try {
+				context.onProgress({
+					stream,
+					message
+				});
+			} catch (error) {
+				callbackError = error;
+				callbackFailed = true;
+				abort();
+			}
+		};
+		child.stdout?.setEncoding("utf8").on("data", (chunk) => progress("stdout", chunk));
+		child.stderr?.setEncoding("utf8").on("data", (chunk) => progress("stderr", chunk));
+		child.on("message", (message) => {
+			response = message;
+		});
+		child.on("error", (error) => {
+			transportError = error;
+		});
+		child.on("close", (code, exitSignal) => {
+			signal?.removeEventListener("abort", abort);
+			if (callbackFailed) return reject(callbackError);
+			if (signal?.aborted) return reject(cancelled());
+			if (transportError) return reject(new StimError({
+				code: "STIM_WORKER_FAILED",
+				message: transportError.message,
+				details: { stderr }
+			}));
+			if (response?.ok === false) return reject(new StimError(response.error));
+			if (code === 0 && response?.ok) return resolve(response.result);
+			reject(new StimError({
+				code: "STIM_WORKER_FAILED",
+				message: `Stim worker exited without a result (${exitSignal ?? code}).`,
+				details: { stderr }
+			}));
+		});
+		child.send?.({
+			...request,
+			projectRoot: context.projectRoot
+		}, (error) => {
+			if (error) transportError = error;
+		});
+	});
+}
+//#endregion
+export { createStim as n, StimError as t };

package/dist/api-run.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/api-run.mjs

@@ -0,0 +1,145 @@
+import { t as StimError } from "./api-DIf_s86s.mjs";
+import { y as refuseRelativeStimPaths } from "./config-DC5jEtd1.mjs";
+import { x as workspaceLogsDir$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { i as runAndroidOperation } from "./android-BXc6BmEi.mjs";
+import { r as runIosOperation } from "./ios-ITYno9rO.mjs";
+import { n as runMacos } from "./macos-ciyBdTY5.mjs";
+import { c as stopWorkspaceNow } from "./stop-zDlknFoz.mjs";
+import { t as runWeb } from "./web-DbbrPUn0.mjs";
+import { queryJsonLogs } from "@stim-cli/core/state";
+//#region src/api-run.ts
+async function dispatch({ projectRoot: root, ...request }) {
+	let directory;
+	try {
+		refuseRelativeStimPaths();
+		directory = workspaceLogsDir$1(root);
+		if (request.operation === "diagnostics") {
+			const { tail = 200, errors = false } = request.options;
+			return {
+				ok: true,
+				result: {
+					directory,
+					records: tail === 0 ? [] : queryJsonLogs({
+						dir: directory,
+						tail,
+						errorsOnly: errors
+					})
+				}
+			};
+		}
+		if (request.operation === "stop") {
+			const result = await stopWorkspaceNow({
+				root,
+				slot: request.options.slot
+			});
+			if ("refusal" in result) throw new StimError({
+				...result.refusal,
+				details: result.remote
+			});
+			return {
+				ok: true,
+				result
+			};
+		}
+		const options = request.options;
+		switch (options.platform) {
+			case "ios": {
+				let error;
+				const result = await runIosOperation(root, options, {}, (failure) => {
+					error = failure;
+				});
+				if (!result) throw new StimError({
+					code: error?.code ?? "STIM_RUN_FAILED",
+					message: error?.message ?? "The iOS run failed.",
+					remedy: error?.remedy,
+					details: error
+				});
+				return {
+					ok: true,
+					result: {
+						platform: "ios",
+						facts: result.facts
+					}
+				};
+			}
+			case "android": {
+				const result = await runAndroidOperation(root, options);
+				if (!result.ok || !result.facts) throw new StimError({
+					code: result.error?.code ?? "STIM_RUN_FAILED",
+					message: result.error?.message ?? "The Android run failed.",
+					remedy: result.error?.remedy
+				});
+				return {
+					ok: true,
+					result: {
+						platform: "android",
+						facts: result.facts
+					}
+				};
+			}
+			case "macos": {
+				const record = await runMacos(root, console.error, void 0, options.remoteBuild);
+				return {
+					ok: true,
+					result: {
+						platform: "macos",
+						facts: {
+							product: record.product,
+							bundle: record.bundle,
+							bundleId: record.bundleId,
+							executable: record.executable,
+							pid: record.app?.pid ?? null,
+							launched: record.app !== void 0,
+							build: record.build,
+							logs: { dir: directory }
+						}
+					}
+				};
+			}
+			case "web": {
+				const result = await runWeb({
+					root,
+					headed: options.headed ?? false,
+					note: console.error
+				});
+				if (!result.ok) throw new StimError(result.error);
+				return {
+					ok: true,
+					result: {
+						platform: "web",
+						facts: result.facts
+					}
+				};
+			}
+			default: throw new StimError({
+				code: "STIM_BAD_ARG",
+				message: "Unknown Stim platform."
+			});
+		}
+	} catch (error) {
+		const failure = error;
+		return {
+			ok: false,
+			error: {
+				code: failure.code ?? "STIM_RUN_FAILED",
+				message: error instanceof Error ? error.message : String(error),
+				remedy: failure.remedy ?? null,
+				details: {
+					logs: directory,
+					cause: failure.details
+				}
+			}
+		};
+	}
+}
+function interrupt() {
+	if (!process.emit("SIGINT")) process.exit(130);
+}
+process.once("disconnect", interrupt);
+process.on("message", async (request) => {
+	if (request.operation === "cancel") return interrupt();
+	const response = await dispatch(request);
+	process.send?.(response, () => process.exit(response.ok ? 0 : 1));
+});
+//#endregion
+export {};

package/dist/api.d.mts

@@ -0,0 +1,218 @@
+import "./state-lKh8shBp.mjs";
+import { i as IosFacts, t as AndroidFacts } from "./build-facts-B87vo-Im.mjs";
+import "./ndjson-Du3j0AQ9.mjs";
+import { MacosBuild, NdjsonRecord, WebBrowserState, WebViewport } from "@stim-cli/core/state";
+import { Command } from "commander";
+import "@stim-cli/cache";
+import { ChildProcess } from "node:child_process";
+//#region src/engine/device-lease.d.ts
+type LeasePlatform = "ios" | "android";
+interface ReleasedLease {
+  platform: LeasePlatform;
+  id: string;
+  deviceName: string | null;
+  expiresAt: string;
+}
+//#endregion
+//#region src/commands/stop.d.ts
+interface SupervisorOutcome {
+  status: string;
+  pid?: number;
+  reason?: string;
+  port?: number | null;
+  mode?: string | null;
+}
+interface CollectorEntry {
+  platform: string;
+  pid: number | null;
+  status: string;
+  reason?: string;
+}
+interface CollectorsOutcome {
+  status: string;
+  entries: CollectorEntry[];
+}
+interface MetroOutcome {
+  status: string;
+  port?: number | null;
+  pid?: number | null;
+  reason?: string;
+}
+interface DeviceOutcomeEntry {
+  status: string;
+  label?: string;
+  reason?: string;
+  kind?: string | null;
+  remedy?: string;
+}
+interface DeviceOutcome {
+  [key: string]: DeviceOutcomeEntry | null | undefined;
+  ios: DeviceOutcomeEntry | null;
+  android: DeviceOutcomeEntry | null;
+  remote?: DeviceOutcomeEntry | null;
+  web?: DeviceOutcomeEntry | null;
+}
+interface PortOutcome {
+  status: string;
+  port?: number | null;
+  reason?: string;
+}
+interface StopOutcomes {
+  supervisor: SupervisorOutcome;
+  collectors: CollectorsOutcome;
+  metro: MetroOutcome;
+  device: DeviceOutcome;
+  macos?: {
+    status: string;
+    reason?: string;
+  };
+  port: PortOutcome;
+  metroTunnel: TunnelOutcome;
+  releasedLeases: ReleasedLease[];
+}
+interface StopResult {
+  ok: boolean;
+  outcomes: StopOutcomes;
+  summary: string;
+}
+interface TunnelOutcome {
+  status: string;
+  provider?: string;
+  reason?: string;
+}
+//#endregion
+//#region src/web/launch.d.ts
+type WebLaunched = true | "bundling" | "unverified";
+//#endregion
+//#region src/commands/web.d.ts
+interface WebFacts extends WebBrowserState {
+  platform: "web";
+  reused: boolean;
+  launched: WebLaunched;
+  metroPort: number | null;
+  logs: {
+    dir: string;
+  };
+  durationMs: number;
+}
+//#endregion
+//#region src/api/types.d.ts
+type StimPlatform = "ios" | "android" | "macos" | "web";
+interface StimProgress {
+  stream: "stdout" | "stderr";
+  message: string;
+}
+interface StimOptions {
+  /** Absolute or relative path to the app directory, resolved once when creating the client. */
+  projectRoot: string;
+  /** Absolute Stim state directory. Omit to use the caller's STIM_HOME or the default home. */
+  home?: string;
+  /** Absolute native artifact cache directory. Its coordinating home must be shared by all writers. */
+  buildCache?: string;
+  /**
+   * Receives output chunks without writing to the importing process's terminal.
+   * An exception cancels the operation and rejects it with that exception.
+   */
+  onProgress?: (event: StimProgress) => void;
+}
+interface NativeRunOptions {
+  slot?: string;
+  metroCheck?: boolean;
+  buildCache?: boolean;
+  remoteBuild?: string;
+}
+type StimRunOptions = ((NativeRunOptions & {
+  platform: "ios";
+  configuration?: string;
+  scheme?: string;
+  deviceType?: string;
+  runtime?: string;
+}) | (NativeRunOptions & {
+  platform: "android";
+  variant?: string;
+  systemImage?: string;
+  deviceProfile?: string;
+}) | {
+  platform: "macos";
+  remoteBuild?: string;
+} | {
+  platform: "web";
+  headed?: boolean;
+}) & {
+  signal?: AbortSignal;
+};
+type StimRunResult = {
+  platform: "ios";
+  facts: IosFacts;
+} | {
+  platform: "android";
+  facts: AndroidFacts;
+} | {
+  platform: "macos";
+  facts: {
+    product: string;
+    bundle: string;
+    bundleId: string;
+    executable: string;
+    pid: number | null;
+    launched: boolean;
+    build: MacosBuild;
+    logs: {
+      dir: string;
+    };
+  };
+} | {
+  platform: "web";
+  facts: WebFacts;
+};
+interface StimStopOptions {
+  slot?: string;
+  signal?: AbortSignal;
+}
+type StimStopResult = StopResult;
+interface StimDiagnosticsOptions {
+  /** Maximum number of records, default 200. Zero returns paths without records. */
+  tail?: number;
+  errors?: boolean;
+  signal?: AbortSignal;
+}
+interface StimDiagnostics {
+  directory: string;
+  records: NdjsonRecord[];
+}
+interface StimClient {
+  readonly projectRoot: string;
+  run<P extends StimPlatform>(options: StimRunOptions & {
+    platform: P;
+  }): Promise<Extract<StimRunResult, {
+    platform: P;
+  }>>;
+  run(options: StimRunOptions): Promise<StimRunResult>;
+  /** Stops this workspace, including resources created before a failed run. Use a fresh signal for cleanup. */
+  stop(options?: StimStopOptions): Promise<StimStopResult>;
+  /** Reads the existing local timeline; available even when run failed before creating any logs. */
+  diagnostics(options?: StimDiagnosticsOptions): Promise<StimDiagnostics>;
+}
+interface StimFailure {
+  code: string;
+  message: string;
+  remedy: string | null;
+  details?: unknown;
+}
+//#endregion
+//#region src/api.d.ts
+declare class StimError extends Error {
+  readonly code: string;
+  readonly remedy: string | null;
+  readonly details: unknown;
+  constructor({ code, message, remedy, details }: Omit<StimFailure, "remedy"> & {
+    remedy?: string | null;
+  });
+}
+/**
+ * Creates a client without starting processes or changing the caller's cwd, environment, or signal handlers.
+ * Each operation runs in a separate Stim worker. Resources remain workspace-owned until stop() is called.
+ */
+declare function createStim(options: StimOptions): StimClient;
+//#endregion
+export { type StimClient, type StimDiagnostics, type StimDiagnosticsOptions, StimError, type StimOptions, type StimPlatform, type StimProgress, type StimRunOptions, type StimRunResult, type StimStopOptions, type StimStopResult, createStim };

package/dist/api.mjs

@@ -0,0 +1,2 @@
+import { n as createStim, t as StimError } from "./api-DIf_s86s.mjs";
+export { StimError, createStim };

package/dist/{app-install-VPkI5WEg.mjs → app-install-CFI4ptUL.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-CaErVv7t.mjs";
-import { D as uninstallIosApp, M as deviceHoldsApk, N as deviceHoldsBundle, l as iosSimulatorFailureAdvice, m as listUserApps } from "./ios-DSfnPfse.mjs";
-import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-Ee7sDXfp.mjs";
+import { n as debugLog, t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { N as deviceHoldsApk, O as uninstallIosApp, P as deviceHoldsBundle, h as listUserApps, u as iosSimulatorFailureAdvice } from "./ios-BWbHFZVz.mjs";
+import { t as DEV_MENU_LAUNCH_ARGS } from "./ios-device-CrW8aMb5.mjs";
 import { join } from "node:path";
 //#region src/engine/app-schemes.ts
 function schemesFromInfoPlist(plist) {
@@ -207,25 +207,45 @@ function parseLaunchedPid(text) {
 }
 function iosAppProcess(udid, bundleId, { exec = null } = {}) {
 	const e = exec || getExecutor();
-	let out = "";
+	const started = performance.now();
+	let pid;
+	let failure = {};
 	try {
-		out = e.runFile("xcrun", [
+		const out = e.runFile("xcrun", [
 			"simctl",
 			"spawn",
 			udid,
 			"launchctl",
 			"list"
 		], { timeoutMs: 2e3 });
-	} catch {
+		const label = `UIKitApplication:${bundleId}[`;
+		pid = null;
+		for (const line of out.split("\n")) {
+			if (!line.includes(label)) continue;
+			const candidate = Number(line.trim().split(/\s+/)[0]);
+			if (Number.isInteger(candidate) && candidate > 0) {
+				pid = candidate;
+				break;
+			}
+		}
+		return pid;
+	} catch (error) {
+		const { code, status } = error ?? {};
+		failure = {
+			...typeof code === "string" ? { code } : {},
+			...typeof status === "number" ? { exit: status } : {}
+		};
 		return;
+	} finally {
+		debugLog.log("ios.app-process", {
+			deviceId: udid,
+			bundleId,
+			state: pid === void 0 ? "unknown" : pid === null ? "absent" : "running",
+			...typeof pid === "number" ? { appPid: pid } : {},
+			ms: Math.round(performance.now() - started),
+			...failure
+		});
 	}
-	const label = `UIKitApplication:${bundleId}[`;
-	for (const line of out.split("\n")) {
-		if (!line.includes(label)) continue;
-		const pid = Number(line.trim().split(/\s+/)[0]);
-		if (Number.isInteger(pid) && pid > 0) return pid;
-	}
-	return null;
 }
 function launchedIosAppAfterNoHandle(error, udid, bundleId, exec) {
 	const stderr = String(error?.stderr ?? "");

package/dist/{attempt-Bk2ouQVL.mjs → attempt-DW-mQqM7.mjs}

@@ -6,10 +6,20 @@ const ATTEMPT_BACKOFF_MS = 6e4;
 function due(state, settings, now, attemptedAt) {
 	const elapsed = (stamp) => stamp === void 0 || stamp > now ? Infinity : now - stamp;
 	if (elapsed(attemptedAt) < ATTEMPT_BACKOFF_MS) return [];
-	return ["pressure", "size"].filter((check) => {
-		if (elapsed(state?.deferredAt?.[check]) < DEFERRED_RETRY_MS) return false;
-		const interval = check === "pressure" ? settings.pressureCheckMinutes : settings.sizeCheckMinutes;
-		return elapsed(state?.lastAt[check]) >= interval * 6e4;
+	const intervalMs = {
+		pressure: settings.pressureCheckMinutes * 6e4,
+		size: settings.sizeCheckMinutes * 6e4,
+		worktree: settings.removeFinishedWorktrees ? settings.worktreeCheckMinutes * 6e4 : Infinity,
+		sweep: settings.sweepHours > 0 ? settings.sweepHours * 36e5 : Infinity
+	};
+	return [
+		"pressure",
+		"size",
+		"worktree",
+		"sweep"
+	].filter((check) => {
+		if (intervalMs[check] === Infinity || elapsed(state?.deferredAt?.[check]) < DEFERRED_RETRY_MS) return false;
+		return elapsed(state?.lastAt[check]) >= intervalMs[check];
 	});
 }
 //#endregion