stim 1.18.0 → 1.20.0

package/dist/react-native-ios-SCTK_CT5.mjs

@@ -0,0 +1,595 @@
+import { G as resolveIosProjectDir, H as remoteIosSetting, L as publicUrlSetting, Q as settingShapeErrors, V as remoteEasFallbackSetting, a as SETTING_SHAPE_REMEDY, p as cacheProviderSettingError, tt as tunnelModeSetting } from "./settings-Bbztm4oV.mjs";
+import { E as fingerprintDiffRecord, L as untrackedMissLine, M as refingerprintAfterMutation, O as inputsChangedDuringBuild, S as configInputsChanged, T as filesystemBuildCapability, b as buildCacheKey, x as changedDuringBuildLine } from "./device-lease-DHOBXGgS.mjs";
+import { i as formatDuration, l as phaseLine, m as shortHash } from "./command-output-BjPN99ZB.mjs";
+import { It as statsProjectKey } from "./budget-BONq9vXY.mjs";
+import { d as optimizationBuildProfile, l as artifactCachePolicy, p as resolveOptimizations } from "./errors-DzkMYh8Q.mjs";
+import { n as fingerprintErrorMissReason, t as explainBuildMiss } from "./miss-reason-BPAzZS0r.mjs";
+import { I as bundlerPin, r as iosToolchain } from "./toolchain-DqyDXs30.mjs";
+import { r as planPayload, t as planCachedBuild } from "./build-plan-CP0tckNU.mjs";
+import { i as planEasDevelopmentBuild, n as easDeviceBuildRemedy } from "./eas-build-Dw_ec2Km.mjs";
+import { i as staleNativeDirRefusal, n as recordPrebuild } from "./prebuild-Bw44QxVh.mjs";
+import { a as deviceModelRefusal, c as iosProjectPathError, f as podAction, h as resolveDeviceType, l as iosProviderRunOptions, m as resolveConfiguration, u as isReleaseConfiguration, v as resolveRuntime, x as simulatorBuildArch, y as resolveSchemeSelection } from "./support-DCco5fut.mjs";
+import { t as IosRecipeRefusal } from "./ios-project-B9drt_aY.mjs";
+import { i as hostedIosSelectors } from "./remote-BU9UyhCJ.mjs";
+import { c as copyAppAside, i as DEFAULT_DEPS, n as iosMetroRuntime, r as iosProcessRuntime, u as writeIpTxt } from "./launch-YrbqaIFj.mjs";
+import { t as planHostedDevice } from "./plan-placement-D_YYlE6N.mjs";
+import { rmSync } from "node:fs";
+import chalk from "chalk";
+//#region src/integrations/react-native-ios-plan.ts
+function note(line) {
+	console.error(line);
+}
+function refuse(refusal, lines = []) {
+	return {
+		refusal,
+		lines
+	};
+}
+async function planReactNativeIos(root, opts, d, schemeProblem, { context: settingsContext, settings }) {
+	const iosProject = resolveIosProjectDir(settings, root);
+	const [shapeError, ...moreShapeErrors] = settingShapeErrors(settings);
+	if (shapeError) return refuse({
+		code: "STIM_BAD_ARG",
+		message: shapeError,
+		remedy: SETTING_SHAPE_REMEDY
+	}, moreShapeErrors);
+	const projectPathError = iosProjectPathError(settings, root, () => d.detectIsExpo(root));
+	if (projectPathError) return refuse({
+		code: "STIM_BAD_ARG",
+		message: projectPathError,
+		remedy: SETTING_SHAPE_REMEDY
+	});
+	let optimizations;
+	try {
+		optimizations = resolveOptimizations(settings);
+	} catch (error) {
+		return refuse({
+			code: "STIM_BAD_ARG",
+			message: error.message,
+			remedy: SETTING_SHAPE_REMEDY
+		});
+	}
+	const cacheProviderError = cacheProviderSettingError(settings);
+	if (cacheProviderError) note(chalk.yellow(phaseLine("cache", `${cacheProviderError} Using the local cache.`)));
+	const slot = opts.slot ?? "default";
+	const target = {
+		platform: "ios",
+		slot,
+		root,
+		projectKey: statsProjectKey({
+			root,
+			commonDir: settingsContext.gitCommonDir,
+			repoRoot: settingsContext.repoRoot
+		})
+	};
+	const isExpo = d.detectIsExpo(root);
+	const settingsLayersForOrigin = d.settingsLayers(settingsContext);
+	const iosRemote = remoteIosSetting(settings);
+	const modelRefusal = deviceModelRefusal({
+		slot,
+		deviceTypeFlag: opts.deviceType,
+		runtimeFlag: opts.runtime,
+		deviceType: resolveDeviceType(opts.deviceType, settings),
+		runtime: resolveRuntime(opts.runtime, settings),
+		deviceTypeOrigin: d.settingOriginScope(settingsLayersForOrigin, "ios.deviceType"),
+		runtimeOrigin: d.settingOriginScope(settingsLayersForOrigin, "ios.runtime"),
+		physical: false,
+		remoteBackend: iosRemote?.kind === "backend" ? iosRemote.backend : null,
+		hosted: iosRemote?.kind === "machine",
+		listRuntimes: d.listIosRuntimes
+	});
+	if (modelRefusal) return refuse(modelRefusal);
+	if (opts.easProfile !== void 0) {
+		const eas = await planEasDevelopmentBuild({
+			root,
+			platform: "ios",
+			profile: opts.easProfile,
+			note,
+			isExpo,
+			selectors: [opts.scheme, opts.configuration],
+			buildCache: opts.buildCache
+		});
+		if (!eas.ok) return refuse(eas);
+		return planPayload(target, {
+			fingerprint: eas.fingerprint,
+			cacheKey: eas.cacheKey,
+			cacheHit: eas.buildId ? "remote" : false,
+			provider: "eas",
+			cacheSkipped: false,
+			prebuild: null,
+			refusal: eas.missing
+		});
+	}
+	if (iosRemote?.kind === "backend") return refuse({
+		code: "STIM_BAD_ARG",
+		message: `ios.remote is ${iosRemote.backend}, whose simulator architecture --plan cannot read without a session.`,
+		remedy: "Run `stim ios` to build for the remote device, or unset ios.remote to plan the owned simulator."
+	});
+	const scheme = resolveSchemeSelection(opts, settings);
+	const refusal = schemeProblem(scheme);
+	if (refusal) return refuse({
+		code: refusal.code,
+		message: refusal.message ?? "",
+		remedy: refusal.remedy ?? ""
+	});
+	const configuration = resolveConfiguration(opts.configuration, settings);
+	const buildProfile = optimizationBuildProfile("ios", optimizations);
+	const cachePolicy = artifactCachePolicy(optimizations, opts.buildCache !== false, isReleaseConfiguration(configuration));
+	let fingerprint;
+	try {
+		fingerprint = await d.fingerprintProject(root, {
+			platform: "ios",
+			iosProjectPath: iosProject.relative
+		});
+	} catch (error) {
+		note(chalk.dim(`Fingerprinting failed: ${error?.message || error}`));
+	}
+	if (!fingerprint?.hash) return refuse({
+		code: "STIM_NO_FINGERPRINT",
+		message: `Could not fingerprint ${root}: @expo/fingerprint produced no hash for it.`,
+		remedy: "Check the project native inputs and the @expo/fingerprint error above, then retry."
+	});
+	const keyArch = (remoteArch) => simulatorBuildArch({
+		physical: false,
+		remoteArch,
+		hostArch: d.hostSimulatorArch(),
+		configuration
+	});
+	let arch = keyArch(null);
+	let placement;
+	if (iosRemote?.kind === "machine") {
+		const planned = await planHostedDevice({
+			root,
+			slot,
+			platform: "ios",
+			machine: iosRemote.machine,
+			selectors: hostedIosSelectors(resolveDeviceType(opts.deviceType, settings), resolveRuntime(opts.runtime, settings)),
+			sameKey: (choice) => keyArch("runtime" in choice ? choice.architecture : null) === arch,
+			...remoteEasFallbackSetting(settings) ? { eas: () => d.checkEasFallback({
+				root,
+				platform: "ios",
+				slot,
+				release: isReleaseConfiguration(configuration),
+				isExpo,
+				tunnelMode: tunnelModeSetting(settings),
+				publicUrl: publicUrlSetting(settings),
+				deviceTypeFlag: opts.deviceType,
+				localOnlyFlags: typeof opts.runtime === "string" ? ["--runtime"] : []
+			}) } : {}
+		});
+		if (planned.kind === "unknown") return refuse({
+			code: "STIM_BAD_ARG",
+			message: `ios.remote is ${iosRemote.machine}, and its simulator architecture is unknown here: ${planned.reason}.`,
+			remedy: "Run `stim ios` to build for the remote device, or unset ios.remote to plan the owned simulator."
+		});
+		placement = planned.placement;
+		if (planned.kind === "hosted" && "runtime" in planned.choice) arch = keyArch(planned.choice.architecture);
+	}
+	const cacheKey = buildCacheKey("ios", fingerprint.hash, {
+		scheme,
+		...configuration ? { configuration } : {},
+		isSimulator: true,
+		...arch ? { arch } : {},
+		...buildProfile ? { buildProfile } : {}
+	});
+	const plan = await planCachedBuild({
+		...target,
+		isExpo,
+		fingerprint: fingerprint.hash,
+		sources: fingerprint.sources ?? [],
+		cacheKey,
+		cachePolicy,
+		providerConfig: d.resolveCacheProviderConfig(settingsContext),
+		expoRemote: cachePolicy.remote && !buildProfile && !scheme ? { runOptions: iosProviderRunOptions(configuration, arch) } : null
+	}, {
+		loadCacheProvider: d.loadCacheProvider,
+		loadProjectProvider: d.loadProjectProvider,
+		checkEasAuth: d.checkEasAuth,
+		resolveRemote: d.resolveRemote,
+		planPrebuild: d.planPrebuild,
+		note
+	});
+	return placement ? {
+		...plan,
+		placement
+	} : plan;
+}
+//#endregion
+//#region src/integrations/react-native-ios.ts
+const PLATFORM = "ios";
+function reactNativeIosSchemeProblem(root, iosDir, scheme, isExpo, d) {
+	if (scheme === void 0) return null;
+	if (!scheme.trim()) return {
+		code: "STIM_BAD_ARG",
+		message: "--scheme must name a non-empty shared Xcode app scheme.",
+		remedy: "Pass the exact scheme name shown by xcodebuild -list."
+	};
+	if (isExpo) return null;
+	const project = d.discoverXcodeProject(root, iosDir);
+	if (project.error) return project.error;
+	return d.resolveScheme(project, { scheme }).error ?? null;
+}
+const runtimeKind = (configuration) => isReleaseConfiguration(configuration) ? "embedded-js" : "metro";
+function reactNativeIosProject(root, settings, dependencies = {}) {
+	const d = {
+		...DEFAULT_DEPS,
+		...dependencies
+	};
+	const isExpo = d.detectIsExpo(root);
+	const iosProject = resolveIosProjectDir(settings, root);
+	return {
+		plan: (options, resolved) => planReactNativeIos(root, options, {
+			...DEFAULT_DEPS,
+			...dependencies
+		}, (scheme) => reactNativeIosSchemeProblem(root, iosProject.dir, scheme, isExpo, d), resolved),
+		isExpo,
+		bundleId: () => d.detectBundleId(root, iosProject.dir),
+		schemeProblem: (scheme) => reactNativeIosSchemeProblem(root, iosProject.dir, scheme, isExpo, d),
+		targets: [
+			"simulator",
+			"physical",
+			"remote",
+			"hosted"
+		],
+		eas: true,
+		runtimeKind,
+		runtime: ({ configuration, prepareMetro, prepareEmbedded }) => runtimeKind(configuration) === "embedded-js" ? iosProcessRuntime(prepareEmbedded, "embedded-js") : iosMetroRuntime(prepareMetro),
+		artifact: (context) => reactNativeIosArtifact(context, isExpo, iosProject, d)
+	};
+}
+function fail(failure) {
+	throw new IosRecipeRefusal(failure);
+}
+function reactNativeIosArtifact({ root, logFile, configuration, buildScheme, buildProfile, target, device, easProfile, optimizations, cache: cachePolicy, phase, note, logWriter, estimates, step, setPodsMs }, isExpo, iosProject, d) {
+	const physical = device !== null;
+	const { udid } = target;
+	const release = isReleaseConfiguration(configuration);
+	const keyOptions = {
+		scheme: buildScheme,
+		...configuration ? { configuration } : {},
+		isSimulator: !physical,
+		...target.keyArch ? { arch: target.keyArch } : {},
+		...buildProfile ? { buildProfile } : {}
+	};
+	let fingerprint = "";
+	let fingerprintSources = [];
+	let storeHash = null;
+	let storeSources = [];
+	let mutatingSteps = [];
+	const identity = () => storeHash ? {
+		hash: storeHash,
+		key: buildCacheKey(PLATFORM, storeHash, keyOptions)
+	} : null;
+	const materialize = async (artifactPath, { fresh: isFresh, ownTemporary }) => {
+		const lanAddress = device?.lanAddress ?? null;
+		const metroPort = device?.metroPort ?? null;
+		const prepareDeviceApp = async (path, physicalDevice, { fresh }) => {
+			const refuse = (code, reason, remedy) => {
+				if (fresh) fail({
+					code,
+					message: reason,
+					remedy,
+					build: { appPath: path }
+				});
+				note(chalk.yellow(phaseLine("cache", `${reason} -- building fresh instead`)));
+				note(chalk.dim(phaseLine("", remedy)));
+				return null;
+			};
+			const gateProfile = () => {
+				const gate = d.gateProfileForDevice({
+					appPath: path,
+					udid: physicalDevice.udid,
+					configuration
+				});
+				return gate.ok ? path : refuse(gate.code, gate.reason, gate.remedy);
+			};
+			if (release) {
+				if (!fresh) {
+					note(chalk.yellow(phaseLine("cache", `a cached ${configuration} device app carries its builder's JS, and the device JS swap lands with phase 6 of appandflow/stim#178 -- building fresh instead, which bakes in this workspace's JS`)));
+					return null;
+				}
+				return gateProfile();
+			}
+			if (d.devClientScheme(root, path)) return gateProfile();
+			let copy;
+			try {
+				copy = copyAppAside(path);
+			} catch (e) {
+				return refuse("STIM_INSTALL_FAILED", `Could not copy ${path} aside to write its ip.txt: ${e?.message || e}`, "Free space in the temporary directory and run the command again.");
+			}
+			ownTemporary(copy.tmpDir);
+			writeIpTxt(copy.appPath, lanAddress, metroPort);
+			const sealed = d.sealAppForDevice({
+				appPath: copy.appPath,
+				udid: physicalDevice.udid,
+				configuration,
+				pinnedName: physicalDevice.signingName ?? null,
+				pinnedSha1: physicalDevice.signingSha1 ?? null
+			});
+			if (!sealed.ok) {
+				try {
+					rmSync(copy.tmpDir, {
+						recursive: true,
+						force: true
+					});
+				} catch {}
+				for (const line of sealed.lastLines ?? []) note(chalk.dim(phaseLine("", line)));
+				return refuse(sealed.code, sealed.reason, sealed.remedy);
+			}
+			phase("ip.txt", `${lanAddress}:${metroPort} written into the install copy and re-sealed with "${sealed.identity.name}"${sealed.mode === "preserve-metadata" ? "" : ` (${sealed.mode})`}`);
+			return copy.appPath;
+		};
+		const installableCachedApp = async (cachedPath) => {
+			if (device) return prepareDeviceApp(cachedPath, device, { fresh: false });
+			if (!release) return cachedPath;
+			phase("swap", `regenerating this workspace's JS for the cached ${configuration} app`);
+			const swap = await d.swapJsBundle({
+				root,
+				iosDir: iosProject.dir,
+				isExpo,
+				cachedAppPath: cachedPath,
+				logWriter: logWriter()
+			});
+			if (swap?.ok && swap.appPath) {
+				if (swap.note) note(chalk.yellow(phaseLine("swap", swap.note)));
+				if (swap.tmpDir) ownTemporary(swap.tmpDir);
+				phase("swap", `${swap.hermes ? "hermes bytecode" : "plain JS"} + assets replaced, re-signed (${formatDuration(swap.durationMs ?? 0)})`);
+				return swap.appPath;
+			}
+			note(chalk.yellow(phaseLine("swap", `failed at ${swap?.step || "unknown step"}: ${swap?.reason || "unknown reason"} -- building fresh instead (a cached ${configuration} app carries its builder's JS; it is never installed after a failed swap)`)));
+			for (const line of swap?.lastLines ?? []) note(chalk.dim(phaseLine("", line)));
+			return null;
+		};
+		if (isFresh) return device ? prepareDeviceApp(artifactPath, device, { fresh: true }) : artifactPath;
+		return installableCachedApp(artifactPath);
+	};
+	return {
+		async identity() {
+			let computedFingerprint;
+			let fingerprintError = "no hash";
+			try {
+				const computed = await d.fingerprintProject(root, {
+					platform: PLATFORM,
+					iosProjectPath: iosProject.relative
+				});
+				computedFingerprint = computed?.hash ?? null;
+				fingerprintSources = computed?.sources ?? [];
+			} catch (error) {
+				computedFingerprint = null;
+				fingerprintError = String(error?.message || error);
+				note(chalk.dim(`Fingerprinting failed: ${fingerprintError}`));
+			}
+			if (!computedFingerprint) fail({
+				code: "STIM_NO_FINGERPRINT",
+				message: `Could not fingerprint ${root}: @expo/fingerprint produced no hash for it.`,
+				remedy: "Check the project native inputs and the @expo/fingerprint error above, then retry.",
+				build: {
+					cacheSkipped: !cachePolicy.read,
+					missReason: fingerprintErrorMissReason(fingerprintError)
+				}
+			});
+			fingerprint = storeHash = computedFingerprint;
+			storeSources = fingerprintSources;
+			return identity();
+		},
+		cache: () => filesystemBuildCapability({
+			resolve: d.resolveBuild,
+			store: d.storeBuild,
+			sources: storeSources
+		}),
+		validateExternal(path) {
+			if (device) {
+				const gate = d.gateProfileForDevice({
+					appPath: path,
+					udid: device.udid,
+					configuration
+				});
+				if (!gate.ok) fail({
+					code: gate.code,
+					message: gate.reason,
+					remedy: easDeviceBuildRemedy(easProfile)
+				});
+				if (!d.devClientScheme(root, path)) fail({
+					code: "STIM_BAD_ARG",
+					message: "The EAS device app has no development-client URL scheme.",
+					remedy: "Install expo-dev-client with npx expo install expo-dev-client, then rebuild the EAS profile and retry."
+				});
+			}
+		},
+		materialize,
+		async prepare(beforePrepare) {
+			mutatingSteps = [];
+			const prebuild = d.planPrebuild(root, PLATFORM, {
+				isExpo,
+				fingerprint,
+				sources: fingerprintSources
+			});
+			if (prebuild === "refuse") fail({ ...staleNativeDirRefusal(PLATFORM) });
+			const pods = d.readPodState(root, iosProject.dir);
+			if ((prebuild === "generate" || prebuild === "regenerate" || podAction(pods, d.podsAreStale(pods.lockText, pods.manifestText, pods.dir)).install) && cachePolicy.read) beforePrepare();
+			if (prebuild === "generate" || prebuild === "regenerate") {
+				step("prebuild");
+				recordPrebuild(root, PLATFORM, null);
+				const result = await d.runPrebuild(root, PLATFORM, logWriter(), { clean: prebuild === "regenerate" });
+				if (result?.failed) {
+					phase("prebuild", "FAILED");
+					fail({
+						code: result.code || "STIM_PREBUILD_FAILED",
+						message: result.reason || "expo prebuild failed.",
+						remedy: result.remedy || `See ${logFile} for the transcript.`,
+						lines: (result.lastLines || []).slice(-5)
+					});
+				}
+				phase("prebuild", `${prebuild === "generate" ? "ios/ absent -> generated" : "ios/ not generated from this fingerprint -> regenerated with --clean"} (${formatDuration(result?.durationMs ?? 0)})`);
+				mutatingSteps.push("prebuild");
+			}
+			if (isExpo && buildScheme !== void 0) {
+				const project = d.discoverXcodeProject(root, iosProject.dir);
+				if (project.error) fail({ ...project.error });
+				const schemeError = d.resolveScheme(project, { scheme: buildScheme }).error;
+				if (schemeError) fail({ ...schemeError });
+			}
+			const podState = d.readPodState(root, iosProject.dir);
+			const verdict = d.podsAreStale(podState.lockText, podState.manifestText, podState.dir);
+			const action = podAction(podState, verdict);
+			if (action.install) {
+				step("pods");
+				const result = await d.runPodInstall(root, logWriter(), {
+					estimateMs: estimates().podsMs,
+					directory: iosProject.dir
+				});
+				const podCommand = result?.command || "pod install";
+				for (const line of result?.notes || []) note(chalk.dim(phaseLine("pods", line)));
+				if (result?.failed) {
+					phase("pods", "FAILED");
+					fail({
+						code: result.code || "STIM_DEPS_FAILED",
+						message: result.reason || "`pod install` failed.",
+						remedy: result.remedy || `See ${logFile} for the transcript.`,
+						lines: result.diagnosticLines?.length ? result.diagnosticLines : (result.lastLines || []).slice(-5)
+					});
+				}
+				setPodsMs(result?.durationMs ?? 0);
+				phase("pods", `${action.reason} -> installed with \`${podCommand}\` (${formatDuration(result?.durationMs ?? 0)})`);
+				mutatingSteps.push(podCommand);
+			}
+		},
+		async reconcile() {
+			const rekeyedBy = [];
+			if (mutatingSteps.length) {
+				const after = await refingerprintAfterMutation({
+					projectRoot: root,
+					platform: PLATFORM,
+					previousHash: fingerprint,
+					iosProjectPath: iosProject.relative,
+					fingerprint: d.fingerprintProject
+				});
+				const prebuildRan = mutatingSteps.includes("prebuild");
+				const editedConfig = after ? configInputsChanged(fingerprintSources, after.sources, { prebuildRan }) : [];
+				if (after && !editedConfig.length && prebuildRan) recordPrebuild(root, PLATFORM, after.hash);
+				if (!after || editedConfig.length) {
+					storeHash = null;
+					note(chalk.yellow(phaseLine("fingerprint", after ? changedDuringBuildLine(editedConfig) : `unavailable after ${mutatingSteps.join(", ")}; the build will be installed but not cached`)));
+				} else if (after.moved) {
+					rekeyedBy.push(...mutatingSteps.map((mutation) => mutation === "prebuild" ? mutation : "pod install"));
+					storeHash = after.hash;
+					storeSources = after.sources;
+					note(chalk.dim(phaseLine("fingerprint", `${shortHash(fingerprint)} -> ${shortHash(storeHash)} (after ${mutatingSteps.join(", ")})`)));
+				}
+			}
+			return {
+				identity: identity(),
+				rekeyedBy,
+				mutationLabel: mutatingSteps.join("/")
+			};
+		},
+		async validate() {
+			if (!storeHash) return null;
+			const after = await refingerprintAfterMutation({
+				projectRoot: root,
+				platform: PLATFORM,
+				previousHash: storeHash,
+				iosProjectPath: iosProject.relative,
+				fingerprint: d.fingerprintProject
+			});
+			const changed = after ? inputsChangedDuringBuild({
+				platform: PLATFORM,
+				lookup: fingerprintSources,
+				prebuildRan: mutatingSteps.includes("prebuild"),
+				compiled: storeSources,
+				current: after.sources
+			}) : [];
+			if (!after || changed.length) {
+				storeHash = null;
+				note(chalk.yellow(phaseLine("fingerprint", after ? changedDuringBuildLine(changed) : "unavailable after xcodebuild; the build will be installed but not cached")));
+			} else if (after.moved) {
+				const before = storeHash;
+				storeHash = after.hash;
+				storeSources = after.sources;
+				note(chalk.dim(phaseLine("fingerprint", `${shortHash(before)} -> ${shortHash(storeHash)} (after xcodebuild)`)));
+			}
+			return identity();
+		},
+		compile: () => d.buildIos({
+			root,
+			iosDir: iosProject.dir,
+			scheme: buildScheme,
+			udid,
+			destination: target.destination,
+			arch: target.arch,
+			...physical ? { sdk: target.sdk } : {},
+			logWriter: logWriter(),
+			...configuration ? { configuration } : {},
+			estimateMs: estimates().coldBuildMs,
+			optimizations
+		}),
+		explain(rekeyedBy) {
+			const current = {
+				hash: storeHash ?? fingerprint,
+				sources: storeSources
+			};
+			const explained = explainBuildMiss({
+				root,
+				platform: PLATFORM,
+				current,
+				rekeyedBy,
+				baselineDeps: { readState: d.readWorkspaceState }
+			});
+			return {
+				reason: explained.reason,
+				diff: explained.previousHash && explained.changedNames.length ? fingerprintDiffRecord({
+					changed: explained.changedNames,
+					previousHash: explained.previousHash,
+					hash: current.hash
+				}) : null
+			};
+		},
+		untrackedLine: () => untrackedMissLine(d.untrackedNativeFiles({
+			projectRoot: root,
+			iosProjectPath: iosProject.relative
+		})),
+		legacyCache: physical || !cachePolicy.remote || buildProfile || buildScheme ? null : {
+			load: () => d.loadProjectProvider(root, { isExpo }),
+			runOptions: iosProviderRunOptions(configuration, target.keyArch)
+		},
+		offload: {
+			context: () => {
+				const runtime = physical || release ? null : target.offloadRuntime();
+				return {
+					runtime,
+					unsupported: target.offloadRefusal ?? (release ? `${configuration} builds build here` : !cachePolicy.write ? "the build cache is off" : !runtime ? udid ? `the runtime of simulator ${udid} is unknown` : "no simulator runtime is available for worker selection" : null)
+				};
+			},
+			target: (runtime) => ({
+				platform: "ios",
+				local: {
+					...iosToolchain(root),
+					...target.hostedArchitecture ? { arch: target.hostedArchitecture === "x86_64" ? "x64" : "arm64" } : {}
+				},
+				runtime,
+				cocoapodsPinned: bundlerPin(root) !== null
+			}),
+			request: (runtime) => ({
+				platform: "ios",
+				runtime,
+				configuration,
+				scheme: buildScheme ?? null,
+				iosProjectPath: iosProject.relative,
+				isExpo,
+				optimizations
+			}),
+			unchanged: async () => {
+				const after = await refingerprintAfterMutation({
+					projectRoot: root,
+					platform: PLATFORM,
+					previousHash: storeHash,
+					iosProjectPath: iosProject.relative,
+					fingerprint: d.fingerprintProject
+				});
+				return Boolean(after && !after.moved);
+			}
+		}
+	};
+}
+//#endregion
+export { reactNativeIosProject };

package/dist/{recordings-BAWltsVt.mjs → recordings-Bk-VivUV.mjs}

@@ -1,4 +1,4 @@
-import { c as gitCommonDirOnDisk } from "./worktree-CsKYexJM.mjs";
+import { ht as gitCommonDirOnDisk } from "./settings-Bbztm4oV.mjs";
 import { existsSync, rmSync } from "node:fs";
 import { loadConfig, recordingEnabled, workspaceRecordingsDir } from "@stim-cli/core/state";
 //#region src/workspace/recordings.ts

package/dist/{reload-DvyWzVjJ.mjs → reload-D34GkY78.mjs}

@@ -1,17 +1,16 @@
-import { f as refuseNoProject, l as phaseLine } from "./command-output-CBtzyIgF.mjs";
-import { B as parseDeviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-CgYMahz7.mjs";
-import { o as findCommandWorkspace } from "./project-C3ChRLZy.mjs";
-import { l as resolveProjectMetro } from "./metro-Dh8T4Ytd.mjs";
-import { i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-C59dqG-Z.mjs";
-import { o as readWebRecord, r as cdpEndpoint, u as webFacts } from "./state-BG-aAk4k.mjs";
-import { Kt as readWorkspaceLaunches } from "./budget-DIhL2BKx.mjs";
-import { J as resolveOwnedAvdSerial } from "./android-DC3ZLuw0.mjs";
-import { T as resolveOwnedIosSim } from "./ios-B3SbOWdw.mjs";
-import { l as probeHostedSession } from "./hosted-client-C-rMtppF.mjs";
-import { r as readHostedNative } from "./ios-state-B2pES6Vs.mjs";
-import { r as reopenHostedAndroidMetro } from "./hosted-android-Bv285t_t.mjs";
-import { p as ensureMetroReverse, s as androidAppProcess, v as iosAppProcess } from "./app-install-D-PUENug.mjs";
-import { n as nativeRunCommand } from "./slot-launch-C1nqh4mu.mjs";
+import { B as parseDeviceSlotKey, p as getProject, z as deviceSlotPlatforms } from "./config-D0LhTY3S.mjs";
+import { i as recordWorkspaceUse, r as readWorkspaceState$1 } from "./workspace-state-CSIFuuDa.mjs";
+import { f as refuseNoProject, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { F as readWorkspaceLaunches, n as findCommandWorkspace } from "./project-B8_duAzW.mjs";
+import { J as resolveOwnedAvdSerial } from "./android-BsYNR81W.mjs";
+import { u as resolveProjectMetro } from "./metro-D_j9sN-B.mjs";
+import { o as readWebRecord, r as cdpEndpoint, u as webFacts } from "./state-DI84A-uu.mjs";
+import { E as resolveOwnedIosSim } from "./ios-CXLIUxXJ.mjs";
+import { p as ensureMetroReverse, s as androidAppProcess, v as iosAppProcess } from "./app-install-0LgaQRT7.mjs";
+import { u as probeHostedSession } from "./hosted-client-Io01s5By.mjs";
+import { r as readHostedNative } from "./ios-state-CjrL2qv-.mjs";
+import { r as reopenHostedAndroidMetro } from "./hosted-android-DQ-Agsd8.mjs";
+import { n as nativeRunCommand } from "./slot-launch-B9hn96wd.mjs";
 import { n as sendToOwnedPage, t as liveWebRecord } from "./page-Bv9s2KwY.mjs";
 import { hostedAndroidDeviceName, hostedNativeRecords } from "@stim-cli/core/state";
 import chalk from "chalk";
@@ -363,6 +362,10 @@ async function runReload({ root, platform = null, deps = {} }) {
 		};
 	}
 	const target = live.find((candidate) => !candidate.record.release && candidate.record.metroPort === project.metroPort) ?? live[0];
+	if (target.record.runtime === "process") return {
+		ok: false,
+		error: failure("STIM_NO_METRO", `${target.record.appId} runs as a native process without Metro.`, `Run \`${nativeRunCommand(target.platform, target.slot)}\` again to rebuild and relaunch the app.`)
+	};
 	if (target.record.release) return {
 		ok: false,
 		error: failure("STIM_RELOAD_RELEASE", `${target.record.appId} was launched with an embedded release bundle.`, `Run \`${nativeRunCommand(target.platform, target.slot)}\` with a Debug configuration or variant before reloading JavaScript.`)