stim 1.19.0 → 1.20.0

package/dist/{ios-DCrkgXEM.mjs → ios-VGvNdsv2.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 //#region src/collector/ios.ts
 const MESSAGE_TYPE_LEVEL = {
 	Debug: "debug",

package/dist/{ios-device-CrW8aMb5.mjs → ios-device-B1B14xND.mjs}

@@ -1,4 +1,4 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
 //#region src/collector/ios-device.ts
 const CONSOLE_ENV = { OS_ACTIVITY_DT_MODE: "enable" };
 const DEV_MENU_LAUNCH_ARGS = [

package/dist/{ios-device-CJ_ZOGky.mjs → ios-device-BreZOpM0.mjs}

@@ -1,6 +1,6 @@
-import { t as getExecutor } from "./exec-i8GDPwq9.mjs";
-import { i as INSTALL_ERROR } from "./app-install-CFI4ptUL.mjs";
-import { n as TOOL_ERROR_PREFIX } from "./ios-device-CrW8aMb5.mjs";
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { n as TOOL_ERROR_PREFIX } from "./ios-device-B1B14xND.mjs";
+import { i as INSTALL_ERROR } from "./app-install-0LgaQRT7.mjs";
 import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";

package/dist/ios-project-B9drt_aY.mjs

@@ -0,0 +1,197 @@
+import { y as workspaceAgentDeviceDir } from "./workspace-state-CSIFuuDa.mjs";
+import { i as formatDuration, l as phaseLine } from "./command-output-BjPN99ZB.mjs";
+import { i as workspaceLinkLine } from "./stim-desktop-8GQX2OV8.mjs";
+import { Dt as recordFinishedBuild } from "./budget-BONq9vXY.mjs";
+import { a as easAuthNote, n as UPLOAD_TIMEOUT_MS, r as cacheLevel, s as isEasAuthFailureText } from "./remote-cache-Bsts6f6Y.mjs";
+import "./launch-verify-BzRdbuO1.mjs";
+import { S as compilationCacheActivityLine, _ as COMPILATION_CACHE_NOT_RUN } from "./toolchain-DqyDXs30.mjs";
+import { i as deviceLabel } from "./support-DCco5fut.mjs";
+import { buildDiagnostics } from "@stim-cli/core/state";
+import chalk from "chalk";
+//#region src/commands/ios/result.ts
+function lastBuildRecord({ devicePlacement, fingerprint = null, cacheKey = null, cacheHit = false, cacheSkipped = false, durationMs = 0, appPath = null, bundleId = null, startedAt, status, errorCode = null, missReason = null, diagnostics = null, configuration = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null }) {
+	const record = {
+		platform: "ios",
+		fingerprint,
+		cacheKey,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		durationMs,
+		appPath,
+		bundleId,
+		startedAt,
+		status,
+		configuration
+	};
+	if (errorCode) record.errorCode = errorCode;
+	if (devicePlacement) record.devicePlacement = devicePlacement;
+	record.buildMachine = buildMachine;
+	if (builtOn) record.builtOn = builtOn;
+	if (offloadedTo) record.offloadedTo = offloadedTo;
+	if (offloadFallback) record.offloadFallback = offloadFallback;
+	if (missReason && !cacheLevel(cacheHit)) record.missReason = missReason;
+	const recorded = status === "failed" ? buildDiagnostics(diagnostics) : [];
+	if (recorded.length) record.diagnostics = recorded;
+	return record;
+}
+function iosFacts({ root, slot, udid, deviceName, deviceType = null, runtime = null, fingerprint, configuration = null, scheme = null, cacheKey, cacheHit, cacheSkipped = false, compilationCache = COMPILATION_CACHE_NOT_RUN, waitedForBuild = null, appPath, bundleId, installSkipped = false, metroPort, logsDir, durationMs, launched = true, webPreviewUrl = null, lease, devServer = null, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null }) {
+	return {
+		platform: "ios",
+		...slot && slot !== "default" ? { slot } : {},
+		udid,
+		deviceName: deviceName ?? null,
+		deviceType: deviceType ?? null,
+		runtime: runtime ?? null,
+		fingerprint,
+		configuration: configuration ?? null,
+		...scheme ? { scheme } : {},
+		cacheKey,
+		cacheHit: cacheLevel(cacheHit),
+		cacheSkipped: Boolean(cacheSkipped),
+		buildMachine,
+		...builtOn ? { builtOn } : {},
+		...offloadedTo ? { offloadedTo } : {},
+		...offloadFallback ? { offloadFallback } : {},
+		compilationCache,
+		waitedForBuild: waitedForBuild ? {
+			pid: waitedForBuild.pid ?? null,
+			ms: waitedForBuild.ms ?? 0
+		} : null,
+		appPath,
+		bundleId,
+		installSkipped: Boolean(installSkipped),
+		launched: launched === "unverified" || launched === "bundling" ? launched : Boolean(launched),
+		metroPort,
+		logs: { dir: logsDir },
+		...root ? { agentDevice: { stateDir: workspaceAgentDeviceDir(root) } } : {},
+		durationMs,
+		...webPreviewUrl ? { webPreviewUrl } : {},
+		...lease === void 0 ? {} : { lease },
+		...devServer ? { devServer } : {}
+	};
+}
+function writeLastBuild(root, record, { record: recordBuild = recordFinishedBuild } = {}) {
+	try {
+		recordBuild(root, record);
+	} catch {}
+	return record;
+}
+async function finishIosUpload(uploadPending, remote, phase, note) {
+	if (!uploadPending) return false;
+	const upload = await uploadPending;
+	if (upload?.uploaded) phase("cache", `uploaded (${remote?.name})`);
+	else if (upload?.timedOut) {
+		note(chalk.yellow(phaseLine("cache", `${remote?.name} upload still running after ${formatDuration(UPLOAD_TIMEOUT_MS)}; not waiting`)));
+		return true;
+	} else if (upload?.failed) {
+		const authNote = remote?.name === "eas" && isEasAuthFailureText(upload.failed) ? easAuthNote({
+			code: "logged-out",
+			reason: upload.failed,
+			phase: "upload"
+		}) : null;
+		note(chalk.yellow(phaseLine("cache", authNote || `${remote?.name} upload failed: ${upload.failed}`)));
+	}
+	return false;
+}
+function reportIosResult({ devicePlacement, host, slot, root, json, release, runtimeKind = release ? "embedded-js" : "metro", configuration, buildScheme = null, metroCheck, metroPort, logsDir, device, udid, appPath, bundleId, installSkipped, elapsed, startedAt, storeHash, storeKey, cacheHit, missReason, compilationCache, useBuildCache, waitedForBuild, launchState, launchWarning, providerName, buildMachine = "auto", builtOn, offloadedTo = null, offloadFallback = null, closeWriter, webPreviewUrl, lease, recordRun, reclaimed = [], devServer = null, links }) {
+	const durationMs = elapsed();
+	recordRun({
+		failed: false,
+		cacheHit,
+		waited: waitedForBuild,
+		durationMs,
+		offloadedTo
+	});
+	writeLastBuild(root, lastBuildRecord({
+		devicePlacement,
+		fingerprint: storeHash,
+		cacheKey: storeKey,
+		cacheHit,
+		cacheSkipped: !useBuildCache,
+		missReason,
+		durationMs,
+		appPath,
+		bundleId,
+		startedAt,
+		status: "ok",
+		configuration: configuration ?? "Debug",
+		buildMachine,
+		builtOn,
+		offloadedTo,
+		offloadFallback
+	}));
+	closeWriter();
+	const facts = iosFacts({
+		root,
+		slot,
+		udid,
+		deviceName: device?.deviceName ?? null,
+		deviceType: device?.deviceType,
+		runtime: device?.runtime,
+		fingerprint: storeHash,
+		configuration,
+		scheme: buildScheme,
+		cacheKey: storeKey,
+		cacheHit,
+		compilationCache,
+		cacheSkipped: !useBuildCache,
+		waitedForBuild,
+		appPath,
+		bundleId,
+		installSkipped,
+		metroPort,
+		logsDir,
+		durationMs,
+		launched: launchState,
+		webPreviewUrl,
+		lease,
+		devServer,
+		buildMachine,
+		builtOn,
+		offloadedTo,
+		offloadFallback
+	});
+	if (devicePlacement) facts.devicePlacement = devicePlacement;
+	if (host) facts.host = host;
+	if (json) console.log(JSON.stringify({
+		...facts,
+		...links ? { links } : {},
+		...reclaimed.length ? { reclaimed } : {}
+	}));
+	else {
+		const summary = `${launchWarning ? "WARNING" : "OK"}: ${bundleId} on ${host ? `${device.deviceName} (iOS ${device.runtime?.replace(/^iOS /, "")}) on ${host.machine}` : deviceLabel(device, udid)}, ` + (runtimeKind === "process" ? `${configuration ?? "Debug"} (native process, no Metro)` : runtimeKind === "embedded-js" ? `${configuration} (embedded JS, no Metro)` : `Metro port ${metroPort}`) + ` (${cacheDescription(cacheHit, providerName, offloadedTo)}, ${formatDuration(durationMs)})`;
+		const outcome = launchWarning ? chalk.yellow(`${summary} -- ${launchWarning}`) : launchState === "unverified" ? chalk.yellow(`${summary} -- launch UNVERIFIED`) : launchState === "bundling" ? chalk.green(`${summary} -- bundle requested, still building`) : chalk.green(summary);
+		const deviceName = device?.deviceName ?? device?.name ?? udid;
+		const cacheResult = useBuildCache ? cacheDescription(cacheHit, providerName, offloadedTo) : `bypassed; ${cacheDescription(false, null, offloadedTo)}`;
+		const metroResult = runtimeKind === "process" ? "native process (no Metro)" : runtimeKind === "embedded-js" ? `embedded (${configuration})` : !metroCheck ? `check skipped on port ${metroPort}` : launchState === "unverified" ? `state unverified on port ${metroPort}` : `running on port ${metroPort}${devServer ? ` (started: ${devServer.reason})` : ""}`;
+		console.log([
+			outcome,
+			phaseLine("device", host ? `${deviceName} (iOS ${device.runtime?.replace(/^iOS /, "")}) on ${host.machine}` : `${deviceName} (${udid})`),
+			phaseLine("app", bundleId),
+			phaseLine(runtimeKind === "process" ? "runtime" : "metro", metroResult),
+			phaseLine("cache", cacheResult),
+			...compilationCache.status === "not-run" ? [phaseLine("compilation cache", compilationCacheActivityLine(compilationCache))] : [],
+			phaseLine("logs", logsDir),
+			phaseLine("agent-device", `AGENT_DEVICE_STATE_DIR=${workspaceAgentDeviceDir(root)}`)
+		].join("\n"));
+		if (facts.webPreviewUrl) console.error(chalk.dim(`Watch this device: ${facts.webPreviewUrl}`));
+		if (links) console.error(chalk.dim(workspaceLinkLine(links)));
+	}
+	return facts;
+}
+function cacheDescription(cacheHit, providerName = null, offloadedTo = null) {
+	if (cacheHit === "remote") return `from ${providerName || "the remote cache"}`;
+	if (cacheHit === "local") return "from cache";
+	return offloadedTo ? `built on ${offloadedTo}` : "built";
+}
+//#endregion
+//#region src/integrations/ios-project.ts
+var IosRecipeRefusal = class extends Error {
+	failure;
+	constructor(failure) {
+		super(failure.message ?? failure.code);
+		this.failure = failure;
+	}
+};
+//#endregion
+export { lastBuildRecord as a, iosFacts as i, cacheDescription as n, reportIosResult as o, finishIosUpload as r, writeLastBuild as s, IosRecipeRefusal as t };

package/dist/{ios-state-By0XuLTQ.mjs → ios-state-CjrL2qv-.mjs}

@@ -1,4 +1,4 @@
-import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-CR9X86xJ.mjs";
+import { a as updateWorkspaceState, r as readWorkspaceState$1 } from "./workspace-state-CSIFuuDa.mjs";
 import { HOSTED_METRO_REQUESTS_KEY, hostedMetroRequests, hostedNativeRecords, isJsonObject, parseHostedNativePlacement, unreadableHostedNative } from "@stim-cli/core/state";
 //#region src/device-host/ios-state.ts
 function readHostedNative(root, platform, slot) {

package/dist/js-swap-C8icNYIY.mjs

@@ -0,0 +1,432 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { Ft as removeTemporaryEntry, Pt as makeTemporaryDirectory } from "./settings-Bbztm4oV.mjs";
+import { r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
+import { t as cleanLine } from "./server-expo-CsYu2aKL.mjs";
+import { M as startBuildHeartbeat, P as tailLines, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DqyDXs30.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/engine/js-swap.ts
+const JS_BUNDLE_NAME = "main.jsbundle";
+const LAST_LINES = 5;
+function hermesEnabledFromProperties(text) {
+	if (typeof text !== "string") return true;
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		return true;
+	}
+	if (!data || typeof data !== "object") return true;
+	const raw = data.hermesEnabled;
+	return raw !== "false" && raw !== false;
+}
+function readHermesEnabled(iosDir) {
+	try {
+		return hermesEnabledFromProperties(readFileSync(join(iosDir, "Podfile.properties.json"), "utf-8"));
+	} catch {
+		return true;
+	}
+}
+const ENTRY_CANDIDATES = [
+	"index.js",
+	"index.ts",
+	"index.tsx",
+	"index.jsx"
+];
+function pickEntryFile(entries) {
+	const names = new Set((Array.isArray(entries) ? entries : []).filter((e) => typeof e === "string"));
+	return ENTRY_CANDIDATES.find((c) => names.has(c)) ?? "index.js";
+}
+function detectEntryFile(root) {
+	let entries;
+	try {
+		entries = readdirSync(root);
+	} catch {
+		return "index.js";
+	}
+	return pickEntryFile(entries);
+}
+function bundleCommand({ isExpo, entryFile, bundleOutput, assetsDest, assetCatalogDest = null }) {
+	const catalogArgs = assetCatalogDest ? ["--asset-catalog-dest", assetCatalogDest] : [];
+	if (isExpo) return {
+		file: "npx",
+		args: [
+			"expo",
+			"export:embed",
+			"--platform",
+			"ios",
+			"--dev",
+			"false",
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest,
+			...catalogArgs
+		]
+	};
+	return {
+		file: "npx",
+		args: [
+			"react-native",
+			"bundle",
+			"--platform",
+			"ios",
+			"--dev",
+			"false",
+			"--entry-file",
+			entryFile,
+			"--bundle-output",
+			bundleOutput,
+			"--assets-dest",
+			assetsDest,
+			...catalogArgs
+		]
+	};
+}
+const ASSET_CATALOG_BUNDLE = "RNAssets.bundle";
+/**
+* Where React Native 0.88+ keeps the app's packager images. With the `RCTUseAssetCatalog` Info.plist
+* key, `react-native-xcode.sh` compiles them with actool into RNAssets.bundle and the native image
+* loader reads only that catalog, so a swap has to rebuild it. Null means loose files under assets/.
+*/
+function assetCatalogTarget(infoPlist) {
+	if (!infoPlist || typeof infoPlist !== "object") return null;
+	const plist = infoPlist;
+	const flag = plist.RCTUseAssetCatalog;
+	if (!(flag === true || flag === 1 || typeof flag === "string" && [
+		"true",
+		"yes",
+		"1"
+	].includes(flag.toLowerCase()))) return null;
+	const families = Array.isArray(plist.UIDeviceFamily) ? plist.UIDeviceFamily : [1];
+	const targetDevices = [...families.includes(1) ? ["iphone"] : [], ...families.includes(2) ? ["ipad"] : []];
+	return {
+		platform: typeof plist.DTPlatformName === "string" ? plist.DTPlatformName : "iphoneos",
+		minimumDeploymentTarget: typeof plist.MinimumOSVersion === "string" ? plist.MinimumOSVersion : "15.1",
+		targetDevices: targetDevices.length ? targetDevices : ["iphone"]
+	};
+}
+function readPlistKey(e, plist, key, format) {
+	try {
+		return e.runFile("plutil", [
+			"-extract",
+			key,
+			format,
+			"-o",
+			"-",
+			plist
+		]);
+	} catch (err) {
+		if (/No value at that key path/.test(describe(err))) return null;
+		throw err;
+	}
+}
+function readAssetCatalogTarget(e, plist) {
+	const flag = readPlistKey(e, plist, "RCTUseAssetCatalog", "raw");
+	if (flag === null) return null;
+	const families = readPlistKey(e, plist, "UIDeviceFamily", "json");
+	return assetCatalogTarget({
+		RCTUseAssetCatalog: flag,
+		DTPlatformName: readPlistKey(e, plist, "DTPlatformName", "raw"),
+		MinimumOSVersion: readPlistKey(e, plist, "MinimumOSVersion", "raw"),
+		UIDeviceFamily: families === null ? void 0 : JSON.parse(families)
+	});
+}
+function actoolArgs({ catalog, out, target }) {
+	return [
+		"actool",
+		catalog,
+		"--compile",
+		out,
+		"--output-format",
+		"human-readable-text",
+		"--errors",
+		"--warnings",
+		"--notices",
+		"--platform",
+		target.platform,
+		"--minimum-deployment-target",
+		target.minimumDeploymentTarget,
+		...target.targetDevices.flatMap((device) => ["--target-device", device])
+	];
+}
+const ASSET_CATALOG_BUNDLE_INFO_PLIST = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>org.reactjs.RNAssets</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundleName</key>
+  <string>RNAssets</string>
+  <key>CFBundlePackageType</key>
+  <string>BNDL</string>
+</dict>
+</plist>
+`;
+const UPDATES_MANIFEST_NAME = "app.manifest";
+/**
+* expo-updates launches the update with the newest `commitTime` among those built for the binary's
+* runtime version, and the embedded one is only a row in that race. A swapped copy keeps the id and
+* `commitTime` the cached build wrote, so an update downloaded after that build would launch instead
+* of the injected bundle. A full build writes a fresh id and `commitTime`; this does the same.
+*/
+function refreshUpdatesManifest(text, { id, commitTime }) {
+	const manifest = JSON.parse(text);
+	if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error(`${UPDATES_MANIFEST_NAME} is not a JSON object`);
+	return JSON.stringify({
+		...manifest,
+		id,
+		commitTime
+	});
+}
+function refreshUpdatesManifestFile(path, commitTime) {
+	writeFileSync(path, refreshUpdatesManifest(readFileSync(path, "utf-8"), {
+		id: randomUUID(),
+		commitTime
+	}));
+}
+const IOS_UPDATES_MANIFESTS = [join("EXUpdates.bundle", UPDATES_MANIFEST_NAME), UPDATES_MANIFEST_NAME];
+const IOS_FRAMEWORK_UPDATES_MANIFEST = join("Frameworks", "EXUpdates.framework", "EXUpdates.bundle", UPDATES_MANIFEST_NAME);
+function hermescPath(root, iosDir, { exists = existsSync } = {}) {
+	const candidates = [
+		join(root, "node_modules", "hermes-compiler", "hermesc", "osx-bin", "hermesc"),
+		join(iosDir, "Pods", "hermes-engine", "destroot", "bin", "hermesc"),
+		join(root, "node_modules", "react-native", "sdks", "hermesc", "osx-bin", "hermesc")
+	];
+	return candidates.find(exists) ?? candidates[candidates.length - 1];
+}
+function hermescArgs({ bundle, out }) {
+	return [
+		"-emit-binary",
+		"-out",
+		out,
+		bundle
+	];
+}
+async function swapJsBundle({ root, iosDir, isExpo, cachedAppPath, logWriter = null, exec = null, spawnFn = null, mkdtemp = () => makeTemporaryDirectory(cachedAppPath, "stim-js-swap-"), exists = existsSync, hermesEnabled = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, onHeartbeat = (line) => console.error(line) }) {
+	const e = exec || getExecutor();
+	const startedAt = now();
+	const elapsed = () => now() - startedAt;
+	let tmp;
+	const fail = (step, reason, lastLines = []) => {
+		logWriter?.write?.({
+			src: "build",
+			level: "error",
+			msg: `JS swap failed at ${step}: ${reason}`,
+			event: "js_swap"
+		});
+		if (tmp) removeTemporaryEntry(tmp);
+		return {
+			failed: true,
+			step,
+			reason,
+			lastLines,
+			durationMs: elapsed()
+		};
+	};
+	let appCopy;
+	try {
+		tmp = mkdtemp();
+		appCopy = join(tmp, basename(cachedAppPath));
+		try {
+			e.runFile("cp", [
+				"-c",
+				"-R",
+				cachedAppPath,
+				appCopy
+			]);
+		} catch {
+			removeTemporaryEntry(appCopy);
+			e.runFile("cp", [
+				"-R",
+				cachedAppPath,
+				appCopy
+			]);
+		}
+	} catch (err) {
+		return fail("copy", `could not copy ${cachedAppPath} aside: ${describe(err)}`);
+	}
+	let catalogTarget;
+	const infoPlistPath = join(appCopy, "Info.plist");
+	try {
+		catalogTarget = readAssetCatalogTarget(e, infoPlistPath);
+	} catch (err) {
+		return fail("catalog", `could not read ${infoPlistPath}: ${describe(err)}`);
+	}
+	const bundleOutput = join(tmp, JS_BUNDLE_NAME);
+	const assetsDest = join(tmp, "assets");
+	const catalogStaging = catalogTarget ? join(tmp, "rn-assets") : null;
+	const catalogDir = catalogStaging ? join(catalogStaging, "RNAssets.xcassets") : null;
+	const command = bundleCommand({
+		isExpo,
+		entryFile: isExpo ? "index.js" : detectEntryFile(root),
+		bundleOutput,
+		assetsDest,
+		assetCatalogDest: catalogStaging
+	});
+	try {
+		mkdirSync(assetsDest, { recursive: true });
+	} catch (err) {
+		return fail("bundle", `could not create ${assetsDest}: ${describe(err)}`);
+	}
+	if (catalogDir) try {
+		mkdirSync(catalogDir, { recursive: true });
+	} catch (err) {
+		return fail("bundle", `could not create ${catalogDir}: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `${command.file} ${command.args.join(" ")}`,
+		event: "js_swap"
+	});
+	const spawn = spawnFn || ((cmd, args, opts) => e.spawn(cmd, args, opts));
+	const transcript = [];
+	const push = (line) => {
+		const msg = cleanLine(line);
+		if (msg.trim() === "") return;
+		transcript.push(msg);
+		logWriter?.write?.({
+			src: "build",
+			level: "debug",
+			msg,
+			raw: true,
+			event: "js_swap"
+		});
+	};
+	let child;
+	try {
+		child = spawn(command.file, command.args, {
+			cwd: root,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: {
+				...process.env,
+				FORCE_COLOR: "0"
+			}
+		});
+	} catch (err) {
+		return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(err)}`);
+	}
+	const reader = {
+		out: createLineReader(push),
+		err: createLineReader(push)
+	};
+	child.stdout?.setEncoding?.("utf-8");
+	child.stderr?.setEncoding?.("utf-8");
+	child.stdout?.on("data", (chunk) => reader.out.push(chunk));
+	child.stderr?.on("data", (chunk) => reader.err.push(chunk));
+	const stopHeartbeat = startBuildHeartbeat({
+		intervalMs: heartbeatMs,
+		elapsed,
+		emit: onHeartbeat,
+		label: "swap"
+	});
+	let outcome;
+	try {
+		outcome = await waitForChild(child);
+	} finally {
+		stopHeartbeat();
+	}
+	reader.out.flush();
+	reader.err.flush();
+	if (outcome.error) return fail("bundle", `could not run ${command.file} ${command.args[0]}: ${describe(outcome.error)}`);
+	if (outcome.code !== 0) {
+		const how = outcome.signal ? `signal ${outcome.signal}` : `exit code ${outcome.code}`;
+		return fail("bundle", `\`${command.args.slice(0, 2).join(" ")}\` failed (${how})`, tailLines(transcript, LAST_LINES));
+	}
+	if (!exists(bundleOutput)) return fail("bundle", `the bundle command exited 0 but wrote no ${JS_BUNDLE_NAME} at ${bundleOutput}`);
+	let hermes = false;
+	let note;
+	if (hermesEnabled ?? readHermesEnabled(iosDir)) {
+		const hermesc = hermescPath(root, iosDir);
+		if (!exists(hermesc)) note = `hermesc not found at ${hermesc}; embedding the plain JS bundle instead of Hermes bytecode`;
+		else {
+			const hbc = join(tmp, `${JS_BUNDLE_NAME}.hbc`);
+			try {
+				e.runFile(hermesc, hermescArgs({
+					bundle: bundleOutput,
+					out: hbc
+				}));
+				e.runFile("mv", [hbc, bundleOutput]);
+				hermes = true;
+			} catch (err) {
+				return fail("hermesc", `hermesc failed on ${bundleOutput}: ${describe(err)}`);
+			}
+		}
+	}
+	try {
+		e.runFile("cp", [bundleOutput, join(appCopy, JS_BUNDLE_NAME)]);
+		e.runFile("cp", [
+			"-R",
+			`${assetsDest}/.`,
+			`${appCopy}/`
+		]);
+	} catch (err) {
+		return fail("replace", `could not replace the JS bundle inside ${appCopy}: ${describe(err)}`);
+	}
+	if (catalogTarget && catalogDir) {
+		const catalogBundle = join(appCopy, ASSET_CATALOG_BUNDLE);
+		try {
+			rmSync(catalogBundle, {
+				recursive: true,
+				force: true
+			});
+			if (readdirSync(catalogDir).some((name) => name.endsWith(".imageset"))) {
+				mkdirSync(catalogBundle);
+				const output = e.runFile("xcrun", actoolArgs({
+					catalog: catalogDir,
+					out: catalogBundle,
+					target: catalogTarget
+				}));
+				if (!exists(join(catalogBundle, "Assets.car"))) return fail("actool", `actool wrote no Assets.car into ${catalogBundle}`, tailLines(output.split("\n"), LAST_LINES));
+				writeFileSync(join(catalogBundle, "Info.plist"), ASSET_CATALOG_BUNDLE_INFO_PLIST);
+			}
+		} catch (err) {
+			const stdout = String(err?.stdout ?? "");
+			return fail("actool", `could not compile the image asset catalog into ${catalogBundle}: ${describe(err)}`, tailLines(stdout.split("\n"), LAST_LINES));
+		}
+	}
+	if (exists(join(appCopy, IOS_FRAMEWORK_UPDATES_MANIFEST))) return fail("updates", `the expo-updates manifest sits inside a nested framework (${IOS_FRAMEWORK_UPDATES_MANIFEST}), where a swap cannot refresh it without re-signing that framework`);
+	for (const manifest of IOS_UPDATES_MANIFESTS.map((name) => join(appCopy, name)).filter(exists)) try {
+		refreshUpdatesManifestFile(manifest, now());
+	} catch (err) {
+		return fail("updates", `could not refresh the expo-updates manifest ${manifest}: ${describe(err)}`);
+	}
+	try {
+		e.runFile("codesign", [
+			"--force",
+			"--sign",
+			"-",
+			appCopy
+		]);
+	} catch (err) {
+		return fail("codesign", `codesign --force --sign - ${appCopy} failed: ${describe(err)}`);
+	}
+	logWriter?.write?.({
+		src: "build",
+		level: "info",
+		msg: `JS swap done: ${hermes ? "hermes bytecode" : "plain JS"} into ${appCopy} in ${elapsed()}ms`,
+		event: "js_swap"
+	});
+	const result = {
+		ok: true,
+		appPath: appCopy,
+		tmpDir: tmp,
+		hermes,
+		durationMs: elapsed()
+	};
+	if (note) result.note = note;
+	return result;
+}
+function describe(err) {
+	return String(err?.message || err);
+}
+//#endregion
+export { swapJsBundle as i, detectEntryFile as n, refreshUpdatesManifestFile as r, UPDATES_MANIFEST_NAME as t };