stim 1.14.0 → 1.16.0

package/dist/support-CAP8qDUF.mjs

@@ -0,0 +1,316 @@
+import { t as getExecutor } from "./exec-CaErVv7t.mjs";
+import { C as emulatorFailureRemedy, D as hostSystemImageArch, K as profileNeedsFoldFeature, N as memoizeEmulatorProbe, S as emulatorDiskSpaceRemedy, T as findBuildTool, W as pickDefaultSystemImage, c as androidPoolNoCandidatesRefusal, l as androidSystemImageAbi, o as androidHome, s as androidPoolCandidates, w as extractEmulatorFailure } from "./android-B_NumVyQ.mjs";
+import { C as pickDevClientScheme } from "./app-install-CKWdbXIX.mjs";
+import { o as unknownAndroidDeviceProfileRefusal, r as layerNote, s as unknownAndroidSystemImageRefusal } from "./device-capacity-BHwxNBlu.mjs";
+import { t as devClientScheme } from "./dev-client-CroAIjjj.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { relative } from "node:path";
+//#region src/commands/android/support.ts
+const PLATFORM = "android";
+function androidVariantSetting(settings) {
+	const android = settings?.["android"];
+	if (!android || typeof android !== "object" || Array.isArray(android)) return null;
+	const raw = android["variant"];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveVariant(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || androidVariantSetting(settings);
+}
+function androidSystemImageSetting(settings) {
+	const android = settings?.["android"];
+	if (!android || typeof android !== "object" || Array.isArray(android)) return null;
+	const raw = android["systemImage"];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveSystemImage(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || androidSystemImageSetting(settings);
+}
+function remoteAvdFlagRefusal({ systemImageFlag, deviceProfileFlag, remoteBackend }) {
+	if (!remoteBackend) return null;
+	const given = [typeof systemImageFlag === "string" && "--system-image", typeof deviceProfileFlag === "string" && "--device-profile"].filter(Boolean).join(" and ");
+	if (!given) return null;
+	return {
+		code: "STIM_BAD_ARG",
+		message: `${given} ${given.includes(" and ") ? "apply" : "applies"} only to a local owned Android emulator; the ${remoteBackend} remote backend chooses its own device.`,
+		remedy: `Drop ${given} for a remote run. For a local owned emulator, drop --remote and unset android.remote with \`stim settings unset android.remote --scope <workspace|repo|committed>\`.`
+	};
+}
+function systemImageRefusal({ slot, flag, resolved, origin = null, physical, remoteBackend, listImages }) {
+	if (slot && slot !== "default" && remoteBackend) return {
+		code: "STIM_BAD_ARG",
+		message: "Named slots currently support local simulators and physical devices.",
+		remedy: "Use the default slot for a remote session."
+	};
+	if (typeof flag === "string" && flag.trim() === "") return {
+		code: "STIM_BAD_ARG",
+		message: "--system-image was given an empty id.",
+		remedy: "Pass `--system-image <id>` with an sdkmanager package id, e.g. \"system-images;android-36;google_apis;arm64-v8a\"."
+	};
+	if (physical || remoteBackend) return null;
+	if (!resolved) return null;
+	let images;
+	try {
+		images = listImages();
+	} catch (error) {
+		return {
+			code: NO_DEVICE,
+			message: `Could not read the installed Android system images: ${error?.message || error}`,
+			remedy: "Check that ANDROID_HOME points at a readable SDK, then try again."
+		};
+	}
+	const refusal = unknownAndroidSystemImageRefusal(resolved, images);
+	if (!refusal) return null;
+	const { message, remedy } = layerNote(refusal, "android.systemImage", flag, origin);
+	return {
+		code: "STIM_BAD_ARG",
+		message,
+		remedy
+	};
+}
+function resolveDeviceProfile(flag, settings) {
+	const fromFlag = typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null;
+	const android = settings?.["android"];
+	const raw = android && typeof android === "object" && !Array.isArray(android) ? android["deviceProfile"] : void 0;
+	return fromFlag || (typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null);
+}
+function deviceProfileRefusal({ flag, resolved, origin = null, physical, remoteBackend, listProfiles }) {
+	if (typeof flag === "string" && flag.trim() === "") return {
+		code: "STIM_BAD_ARG",
+		message: "--device-profile was given an empty id.",
+		remedy: "Pass `--device-profile <id>` with an id `avdmanager list device -c` prints, e.g. \"pixel_fold\"."
+	};
+	if (physical || remoteBackend || !resolved) return null;
+	let profiles;
+	try {
+		profiles = listProfiles();
+	} catch (error) {
+		return {
+			code: NO_DEVICE,
+			message: `Could not list the Android hardware profiles with avdmanager: ${error?.message || error}`,
+			remedy: "Check that JAVA_HOME and ANDROID_HOME are set and the SDK command-line tools are installed, then try again."
+		};
+	}
+	const refusal = unknownAndroidDeviceProfileRefusal(resolved, profiles);
+	if (!refusal) return null;
+	const { message, remedy } = layerNote(refusal, "android.deviceProfile", flag, origin);
+	return {
+		code: "STIM_BAD_ARG",
+		message,
+		remedy
+	};
+}
+function foldableImageRefusal({ profile, image, avdName, images, supportsFold }) {
+	if (!profileNeedsFoldFeature(profile) || !image || supportsFold(image)) return null;
+	const compatible = pickDefaultSystemImage(images().filter((candidate) => supportsFold(candidate.pkg)))?.pkg;
+	const message = `${avdName ? `This workspace's emulator ${avdName} uses device profile ${profile} on ${image}` : `Device profile ${profile} with system image ${image}`}, which the emulator refuses to boot: ${profile} needs a system image with foldable support (SupportPixelFold in its advancedFeatures.ini).`;
+	if (!compatible) return {
+		code: "STIM_BAD_ARG",
+		message,
+		remedy: `Install an image with foldable support, e.g. \`sdkmanager "system-images;android-36;google_apis;${hostSystemImageArch()}"\`, then pass it with \`--system-image\`, or pick another \`--device-profile\`.`
+	};
+	return {
+		code: "STIM_BAD_ARG",
+		message,
+		remedy: avdName ? `Pass \`--system-image "${compatible}"\`: it replaces ${avdName} if that emulator never finished a boot. Otherwise add \`--slot <name>\` to create the foldable beside it.` : `Pass \`--system-image "${compatible}"\` (or set android.systemImage to it), or pick another \`--device-profile\`.`
+	};
+}
+function isReleaseVariant(variant) {
+	return typeof variant === "string" && /release$/i.test(variant.trim());
+}
+const NO_FINGERPRINT = "STIM_NO_FINGERPRINT";
+const NO_DEVICE = "STIM_NO_DEVICE";
+const INSTALL_FAILED = "STIM_INSTALL_FAILED";
+const LAUNCH_FAILED = "STIM_LAUNCH_FAILED";
+function findAapt(home = androidHome(), { readDir = readdirSync, exists = existsSync } = {}) {
+	const found = findBuildTool(["aapt", "aapt2"], {
+		home,
+		readDir,
+		exists
+	});
+	return found ? {
+		path: found.path,
+		tool: found.tool,
+		version: found.version
+	} : null;
+}
+function dumpApkManifest(apkPath, { exec = null, aapt = null } = {}) {
+	if (typeof apkPath !== "string" || apkPath.trim() === "") return null;
+	const tool = aapt || findAapt();
+	if (!tool) return null;
+	const e = exec || getExecutor();
+	const args = tool.tool === "aapt2" ? [
+		"dump",
+		"xmltree",
+		"--file",
+		"AndroidManifest.xml",
+		apkPath
+	] : [
+		"dump",
+		"xmltree",
+		apkPath,
+		"AndroidManifest.xml"
+	];
+	try {
+		const out = e.runFile(tool.path, args);
+		return typeof out === "string" && out.includes("E: manifest") ? out : null;
+	} catch {
+		return null;
+	}
+}
+function parseXmltree(text) {
+	const root = {
+		tag: "#root",
+		attrs: {},
+		children: [],
+		indent: -1
+	};
+	const stack = [root];
+	for (const raw of String(text ?? "").split("\n")) {
+		const indent = raw.search(/\S/);
+		if (indent < 0) continue;
+		const line = raw.trim();
+		const element = /^E: ([\w.:-]+)/.exec(line);
+		if (element) {
+			while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
+			const node = {
+				tag: element[1],
+				attrs: {},
+				children: [],
+				indent
+			};
+			stack[stack.length - 1].children.push(node);
+			stack.push(node);
+			continue;
+		}
+		const attr = /^A: ([^(=]+?)(?:\(0x[0-9a-f]+\))?=(.*)$/.exec(line);
+		if (attr && stack.length > 1) {
+			const name = attr[1].replace(/^http:\/\/schemas\.android\.com\/apk\/res\/android:/, "android:");
+			const value = /^"((?:[^"\\]|\\.)*)"/.exec(attr[2]);
+			stack[stack.length - 1].attrs[name] = value ? value[1] : null;
+		}
+	}
+	return root;
+}
+function eachNode(node, fn) {
+	fn(node);
+	for (const child of node.children) eachNode(child, fn);
+}
+function apkPackage(text) {
+	const pkg = parseXmltree(text).children.find((c) => c.tag === "manifest")?.attrs["package"];
+	return typeof pkg === "string" && pkg.trim() ? pkg.trim() : null;
+}
+function apkDevClientFacts(text) {
+	const root = parseXmltree(text);
+	const facts = {
+		devClient: false,
+		schemes: []
+	};
+	let launchable = null;
+	eachNode(root, (node) => {
+		const name = node.attrs["android:name"];
+		if (typeof name === "string" && name.startsWith("expo.modules.devlauncher")) facts.devClient = true;
+		if (node.tag !== "activity" && node.tag !== "activity-alias") return;
+		const filters = node.children.filter((c) => c.tag === "intent-filter");
+		if (!filters.some((f) => f.children.some((c) => c.tag === "action" && c.attrs["android:name"] === "android.intent.action.MAIN")) || launchable) return;
+		launchable = node;
+		for (const filter of filters) for (const data of filter.children) {
+			if (data.tag !== "data") continue;
+			const scheme = data.attrs["android:scheme"];
+			if (typeof scheme === "string" && scheme.trim()) facts.schemes.push(scheme.trim());
+		}
+	});
+	return facts;
+}
+function androidDevClientScheme(root, apkPath, { exec = null, dump = dumpApkManifest, aapt = null } = {}) {
+	const text = dump(apkPath, {
+		exec,
+		aapt
+	});
+	if (text) {
+		const facts = apkDevClientFacts(text);
+		if (!facts.devClient) return void 0;
+		const scheme = pickDevClientScheme(facts.schemes);
+		if (scheme) return scheme;
+	}
+	return devClientScheme(root, null);
+}
+function noDeviceDiagnostic({ reason, logFile, remedy, localEmulator = true, readLog = readEmulatorLogTail }) {
+	const text = localEmulator ? readLog(logFile) : "";
+	const logPath = text.trim() ? logFile : null;
+	const found = extractEmulatorFailure(text);
+	const diskRemedy = localEmulator ? emulatorDiskSpaceRemedy([reason, ...found]) : null;
+	if (found.length === 0) return {
+		message: reason,
+		remedy: diskRemedy ?? remedy,
+		lines: [],
+		logPath
+	};
+	return {
+		message: `${reason} The emulator reported: ${found[0]}`,
+		remedy: diskRemedy ?? emulatorFailureRemedy(found),
+		lines: found.slice(1),
+		logPath
+	};
+}
+function readEmulatorLogTail(file) {
+	try {
+		return readFileSync(file, "utf-8").split("\n").slice(-400).join("\n");
+	} catch {
+		return "";
+	}
+}
+function displayPath(root, path) {
+	const rel = relative(root, path);
+	return rel && !rel.startsWith("..") ? rel : path;
+}
+async function pooledAndroidDevice({ root, selectPool, listDevices, isEmulatorDevice, deviceModel, waitSeconds, noWait, now, warn }) {
+	const isEmulator = memoizeEmulatorProbe(isEmulatorDevice);
+	const pooled = await selectPool({
+		root,
+		platform: PLATFORM,
+		idLabel: "serial",
+		list: () => androidPoolCandidates(listDevices(), isEmulator).map((entry) => ({ id: entry.serial })),
+		noCandidates: () => {
+			const resolved = androidPoolNoCandidatesRefusal(listDevices(), isEmulator);
+			return {
+				message: resolved.error,
+				remedy: resolved.remedy
+			};
+		},
+		waitSeconds,
+		noWait,
+		now,
+		warn
+	});
+	if (pooled.status === "refused") {
+		const { code, message, remedy, lease } = pooled.refusal;
+		return {
+			code,
+			message,
+			remedy,
+			extra: lease === null ? {} : { lease }
+		};
+	}
+	return { device: {
+		serial: pooled.candidate.id,
+		deviceName: deviceModel(pooled.candidate.id) ?? pooled.candidate.id,
+		owned: false
+	} };
+}
+function androidBuildOptions({ release, physical, device, variant, deviceAbi, compiler, buildProfile, targetAbiOnly = true }) {
+	let abi = null;
+	if (targetAbiOnly && !release && physical && device.serial) abi = deviceAbi(device.serial);
+	if (targetAbiOnly && !release && !physical) abi = androidSystemImageAbi(device.systemImage);
+	const runOptions = {};
+	if (variant) runOptions.variant = variant;
+	if (abi) runOptions.abi = abi;
+	if (compiler) runOptions.compiler = compiler;
+	if (buildProfile) runOptions.buildProfile = buildProfile;
+	return {
+		abi,
+		runOptions,
+		remoteRunOptions: Object.keys(runOptions).length === 0 ? null : runOptions
+	};
+}
+//#endregion
+export { resolveSystemImage as C, resolveDeviceProfile as S, systemImageRefusal as T, isReleaseVariant as _, PLATFORM as a, pooledAndroidDevice as b, androidSystemImageSetting as c, apkPackage as d, deviceProfileRefusal as f, foldableImageRefusal as g, findAapt as h, NO_FINGERPRINT as i, androidVariantSetting as l, dumpApkManifest as m, LAUNCH_FAILED as n, androidBuildOptions as o, displayPath as p, NO_DEVICE as r, androidDevClientScheme as s, INSTALL_FAILED as t, apkDevClientFacts as u, noDeviceDiagnostic as v, resolveVariant as w, remoteAvdFlagRefusal as x, parseXmltree as y };

package/dist/support-D4aYJniO.mjs

@@ -0,0 +1,201 @@
+import { h as shortUdid, l as phaseLine } from "./command-output-DnJMdEY-.mjs";
+import { x as workspaceLogsDir } from "./workspace-state-B8-aJ1_5.mjs";
+import { k as parseIosSimulatorApp } from "./ios-BaInn3sW.mjs";
+import { x as describeDiagnostic } from "./toolchain-DkUflduf.mjs";
+import { c as unknownIosDeviceTypeRefusal, l as unknownIosRuntimeRefusal, r as layerNote } from "./device-capacity-BHwxNBlu.mjs";
+import { l as parseDeviceWait } from "./device-lease-run-CqjShqWW.mjs";
+import { t as IosDeviceMismatchError } from "./device-ios-BadmeL2V.mjs";
+import { basename, join } from "node:path";
+import chalk from "chalk";
+function buildLogFile(root) {
+	return join(workspaceLogsDir(root), `build-ios.ndjson`);
+}
+const MAX_PRINTED_DIAGNOSTICS = 6;
+function deviceLabel(device, udid) {
+	const name = device?.deviceName || device?.name || null;
+	return name ? `${name} (${shortUdid(udid)})` : shortUdid(udid);
+}
+function deviceShortName(device, udid) {
+	return device?.deviceName || device?.name || shortUdid(udid);
+}
+function appNameFromPath(appPath) {
+	if (typeof appPath !== "string" || appPath.trim() === "") return null;
+	const name = basename(appPath).replace(/\.app$/i, "");
+	return name === "" ? null : name;
+}
+function iosConfigurationSetting(settings) {
+	const ios = settings?.["ios"];
+	if (!ios || typeof ios !== "object" || Array.isArray(ios)) return null;
+	const raw = ios["configuration"];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveConfiguration(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || iosConfigurationSetting(settings);
+}
+function iosStringSetting(settings, key) {
+	const ios = settings?.["ios"];
+	if (!ios || typeof ios !== "object" || Array.isArray(ios)) return null;
+	const raw = ios[key];
+	return typeof raw === "string" && raw.trim() !== "" ? raw.trim() : null;
+}
+function resolveDeviceType(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || iosStringSetting(settings, "deviceType");
+}
+function resolveRuntime(flag, settings) {
+	return (typeof flag === "string" && flag.trim() !== "" ? flag.trim() : null) || iosStringSetting(settings, "runtime");
+}
+function resolveSimulatorAppFlag(flag, physical, remoteBackend) {
+	if (flag === void 0) return {};
+	let simulatorApp;
+	try {
+		simulatorApp = parseIosSimulatorApp(flag, "--simulator-app");
+	} catch (error) {
+		return { refusal: {
+			code: "STIM_BAD_ARG",
+			message: error.message
+		} };
+	}
+	if (physical || remoteBackend) return { refusal: {
+		code: "STIM_BAD_ARG",
+		message: "--simulator-app only applies to a local owned iOS simulator.",
+		remedy: "Drop --simulator-app when using a physical or remote device."
+	} };
+	return { simulatorApp };
+}
+function deviceModelRefusal({ slot, deviceTypeFlag, runtimeFlag, deviceType, runtime, deviceTypeOrigin = null, runtimeOrigin = null, physical, remoteBackend, hosted = false, listRuntimes }) {
+	if (slot && slot !== "default" && remoteBackend) return {
+		code: "STIM_BAD_ARG",
+		message: "Named slots currently support local simulators and physical devices.",
+		remedy: "Use the default slot for a remote session."
+	};
+	if (typeof deviceTypeFlag === "string" && deviceTypeFlag.trim() === "") return {
+		code: "STIM_BAD_ARG",
+		message: "--device-type was given an empty name.",
+		remedy: "Pass `--device-type <name>` with a model `xcrun simctl list devicetypes` names, e.g. \"iPad Pro 13-inch (M5)\"."
+	};
+	if (typeof runtimeFlag === "string" && runtimeFlag.trim() === "") return {
+		code: "STIM_BAD_ARG",
+		message: "--runtime was given an empty version.",
+		remedy: "Pass `--runtime <version>` with a runtime `xcrun simctl list runtimes` reports, e.g. \"18.5\"."
+	};
+	if (remoteBackend) {
+		const eas = remoteBackend === "eas";
+		const given = [!eas && deviceTypeFlag && "--device-type", runtimeFlag && "--runtime"].filter(Boolean).join(" and ");
+		if (given) return {
+			code: "STIM_BAD_ARG",
+			message: `${given} ${given.includes(" and ") ? "apply" : "applies"} only to a local owned iOS simulator; the ${remoteBackend} remote backend chooses its own ${eas ? "iOS runtime" : "device"}.`,
+			remedy: `Drop ${given} for a remote run. For a local owned simulator, drop --remote and unset ios.remote with \`stim settings unset ios.remote --scope <workspace|repo|committed>\`.`
+		};
+		return null;
+	}
+	if (physical || hosted) return null;
+	if (!deviceType && !runtime) return null;
+	let runtimes;
+	try {
+		runtimes = listRuntimes();
+	} catch (error) {
+		return {
+			code: "STIM_NO_DEVICE",
+			message: `Could not read the installed simulator runtimes: ${error?.message || error}`,
+			remedy: "Run `stim doctor` to check the simulator toolchain, then try again."
+		};
+	}
+	const runtimeRefusal = unknownIosRuntimeRefusal(runtime, runtimes);
+	if (runtimeRefusal) {
+		const { message, remedy } = layerNote(runtimeRefusal, "ios.runtime", runtimeFlag, runtimeOrigin);
+		return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
+	}
+	const deviceTypeRefusal = unknownIosDeviceTypeRefusal(deviceType, runtimes, runtime);
+	if (deviceTypeRefusal) {
+		const { message, remedy } = layerNote(deviceTypeRefusal, "ios.deviceType", deviceTypeFlag, deviceTypeOrigin);
+		return {
+			code: "STIM_BAD_ARG",
+			message,
+			remedy
+		};
+	}
+	return null;
+}
+function ownedSimFailure(error) {
+	return {
+		code: "STIM_NO_DEVICE",
+		message: `Could not ensure an owned iOS simulator: ${error?.message || error}`,
+		remedy: error instanceof IosDeviceMismatchError ? error.remedy : "Run `stim doctor` to check the simulator toolchain, then try again."
+	};
+}
+function isReleaseConfiguration(configuration) {
+	return typeof configuration === "string" && configuration.trim() !== "" && configuration.trim().toLowerCase() !== "debug";
+}
+function simulatorBuildArch({ physical, remoteArch, hostArch, configuration }) {
+	if (physical) return null;
+	if (remoteArch) return remoteArch;
+	return isReleaseConfiguration(configuration) ? null : hostArch;
+}
+function iosProviderRunOptions(configuration, arch) {
+	if (arch) return {
+		configuration: configuration || "Debug",
+		arch
+	};
+	return configuration ? { configuration } : null;
+}
+function podAction(podState, verdict) {
+	if (verdict?.stale) return {
+		install: true,
+		reason: verdict.reason
+	};
+	if (verdict?.noPods && podState?.hasPodfile) return {
+		install: true,
+		reason: "ios/Podfile exists but no pods are installed"
+	};
+	return { install: false };
+}
+function xcodeFailureReport(result, logPath) {
+	const diagnostics = result.diagnostics;
+	const code = result.exitCode;
+	const how = code === null ? "" : ` (exit code ${code})`;
+	return {
+		message: diagnostics.length ? `\`xcodebuild\` failed${how} with ${diagnostics.length} diagnostic${diagnostics.length === 1 ? "" : "s"}.` : `\`xcodebuild\` failed${how} with no recognizable diagnostic.`,
+		remedy: diagnostics.find((d) => d?.remedy)?.remedy || `See ${logPath} for the transcript.`
+	};
+}
+function printDiagnostics(note, result) {
+	const diagnostics = result.diagnostics;
+	const shown = diagnostics.slice(0, MAX_PRINTED_DIAGNOSTICS);
+	for (const diagnostic of shown) note(chalk.red(phaseLine("error", describeDiagnostic(diagnostic))));
+	const hidden = diagnostics.length - shown.length + result.truncated;
+	if (hidden > 0) note(chalk.dim(phaseLine("error", `... and ${hidden} more diagnostic${hidden === 1 ? "" : "s"} in the log`)));
+	if (diagnostics.length === 0) {
+		note(chalk.red(phaseLine("error", "xcodebuild failed with no recognizable diagnostic; last lines:")));
+		for (const line of result.tail.slice(-5)) note(chalk.dim(phaseLine("", line)));
+	}
+}
+function resolveIosWait(opts, physical) {
+	const noWait = opts.wait === false;
+	const waitFlagged = opts.wait !== void 0;
+	if (opts.waitConflict) return { failure: {
+		code: "STIM_BAD_ARG",
+		message: "--wait and --no-wait ask for opposite things.",
+		remedy: "Pass `--wait <seconds>` to wait for the lease, or `--no-wait` to install without one."
+	} };
+	if (waitFlagged && !physical) return { failure: {
+		code: "STIM_BAD_ARG",
+		message: "--wait and --no-wait only apply to a `--device` run.",
+		remedy: "This workspace owns its simulator, so nothing contends for it. Drop the flag, or pass `--device`."
+	} };
+	const waitParsed = parseDeviceWait(noWait ? void 0 : opts.wait);
+	if ("error" in waitParsed) return { failure: {
+		code: "STIM_BAD_ARG",
+		message: waitParsed.error,
+		remedy: "Pass a whole number of seconds, e.g. --wait 90. `--wait 0` refuses a leased device at once."
+	} };
+	return {
+		waitSeconds: waitParsed.seconds,
+		noWait
+	};
+}
+//#endregion
+export { simulatorBuildArch as _, deviceShortName as a, isReleaseConfiguration as c, printDiagnostics as d, resolveConfiguration as f, resolveSimulatorAppFlag as g, resolveRuntime as h, deviceModelRefusal as i, ownedSimFailure as l, resolveIosWait as m, buildLogFile as n, iosConfigurationSetting as o, resolveDeviceType as p, deviceLabel as r, iosProviderRunOptions as s, appNameFromPath as t, podAction as u, xcodeFailureReport as v };