stim 1.18.0 → 1.20.0

package/dist/native-xcode-ios-DP3cHLwu.mjs

@@ -0,0 +1,434 @@
+import { t as getExecutor } from "./exec-B81Qodjn.mjs";
+import { r as register } from "./cache-manifest-qA3dT2x2.mjs";
+import { Et as repoRoot, H as remoteIosSetting, Q as settingShapeErrors, W as resolveCacheProviderConfig, mt as gitCommonDir, q as resolveSettings } from "./settings-Bbztm4oV.mjs";
+import { T as filesystemBuildCapability, b as buildCacheKey } from "./device-lease-DHOBXGgS.mjs";
+import { g as sharedCompilationCache } from "./workspace-state-CSIFuuDa.mjs";
+import { f as NativeXcodeError, h as selectNativeXcodeProject, m as pbxString } from "./project-B8_duAzW.mjs";
+import { It as statsProjectKey } from "./budget-BONq9vXY.mjs";
+import { l as artifactCachePolicy, p as resolveOptimizations } from "./errors-DzkMYh8Q.mjs";
+import { a as nativeTransferRefusal } from "./client-BLy1Pw2V.mjs";
+import { i as skippedMissReason, t as explainBuildMiss } from "./miss-reason-BPAzZS0r.mjs";
+import { C as compilationCacheSettings, D as parseXcodeMajor, E as parseSwiftVersion, f as podsAreStale, g as runPodInstall, h as runCaptured, p as readPodState, r as iosToolchain, x as buildXcode, y as HEARTBEAT_INTERVAL_MS } from "./toolchain-DqyDXs30.mjs";
+import { n as planFlagRefusal, t as planCachedBuild } from "./build-plan-CP0tckNU.mjs";
+import { a as deviceModelRefusal, h as resolveDeviceType, m as resolveConfiguration, v as resolveRuntime, x as simulatorBuildArch, y as resolveSchemeSelection } from "./support-DCco5fut.mjs";
+import { t as IosRecipeRefusal } from "./ios-project-B9drt_aY.mjs";
+import { d as gateProfileForDevice, i as DEFAULT_DEPS, r as iosProcessRuntime } from "./launch-YrbqaIFj.mjs";
+import { a as nativeXcodeSources, i as nativeXcodePackages, n as nativeXcodeInputSnapshot, t as nativeXcodeHasPackages } from "./native-xcode-inputs-eutS19jU.mjs";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+//#region src/integrations/native-xcode-ios.ts
+function toolchain(sdk) {
+	const executor = getExecutor();
+	const identity = {
+		xcode: executor.runFile("xcodebuild", ["-version"], { timeoutMs: 1e4 }),
+		sdk: executor.runFile("xcodebuild", [
+			"-version",
+			"-sdk",
+			sdk
+		], { timeoutMs: 1e4 }),
+		swift: executor.runFile("xcrun", ["swift", "--version"], { timeoutMs: 1e4 }),
+		clang: executor.runFile("xcrun", ["clang", "--version"], { timeoutMs: 1e4 }),
+		developer: executor.runFile("xcode-select", ["-p"], { timeoutMs: 1e4 }),
+		developerOverride: process.env.DEVELOPER_DIR ?? "",
+		toolchains: process.env.TOOLCHAINS ?? ""
+	};
+	if (!identity.xcode.trim() || !identity.sdk.trim() || !identity.swift.trim() || !identity.clang.trim() || !identity.developer.trim()) throw new Error("An Xcode toolchain probe returned no identity.");
+	return identity;
+}
+function refusal(error) {
+	return error instanceof NativeXcodeError ? {
+		code: error.code,
+		message: error.message,
+		remedy: error.remedy
+	} : {
+		code: "STIM_BAD_ARG",
+		message: error.message,
+		remedy: "Check the native Xcode project and its selected toolchain, then retry."
+	};
+}
+function settingsContext(root) {
+	return {
+		projectPath: root,
+		gitCommonDir: gitCommonDir(root),
+		repoRoot: repoRoot(root)
+	};
+}
+function nativeRecipe(root, context) {
+	const configuration = context.configuration ?? "Debug";
+	let selected = selectNativeXcodeProject(root, context.buildScheme, configuration);
+	let tools = null;
+	let snapshot = null;
+	let ineligible = null;
+	const mutations = [];
+	const identity = (value) => ({
+		hash: value.hash,
+		key: buildCacheKey("ios", value.hash, {
+			configuration,
+			scheme: selected.scheme,
+			isSimulator: context.target.sdk === "iphonesimulator",
+			...context.target.keyArch ? { arch: context.target.keyArch } : {}
+		})
+	});
+	const reselect = () => {
+		try {
+			selected = selectNativeXcodeProject(root, context.buildScheme, configuration);
+		} catch (error) {
+			throw new IosRecipeRefusal(refusal(error));
+		}
+	};
+	const read = () => {
+		if (!tools) return { cacheIneligible: ineligible ?? "Xcode toolchain identity is unavailable" };
+		reselect();
+		return nativeXcodeInputSnapshot(root, selected, {
+			sdk: context.target.sdk,
+			architecture: context.target.keyArch,
+			toolchain: tools,
+			optimizations: context.optimizations
+		}, repoRoot(root) ?? root);
+	};
+	return {
+		async identity() {
+			try {
+				tools = toolchain(context.target.sdk);
+			} catch (error) {
+				ineligible = `Xcode toolchain identity is unavailable: ${error.message}`;
+				return { cacheIneligible: ineligible };
+			}
+			const value = read();
+			if ("cacheIneligible" in value) {
+				ineligible = value.cacheIneligible;
+				return value;
+			}
+			snapshot = value;
+			return identity(value);
+		},
+		cache: () => filesystemBuildCapability({ sources: snapshot ? nativeXcodeSources(snapshot) : null }),
+		async prepare(beforePrepare) {
+			const pods = readPodState(root, root);
+			const state = podsAreStale(pods.lockText, pods.manifestText);
+			if (pods.hasPodfile && (state.stale || state.noPods)) {
+				beforePrepare();
+				context.step("pods");
+				const result = await runPodInstall(root, context.logWriter(), {
+					directory: root,
+					estimateMs: context.estimates().podsMs
+				});
+				if (result.failed) throw new IosRecipeRefusal({
+					code: result.code ?? "STIM_DEPS_FAILED",
+					message: result.reason,
+					remedy: result.remedy ?? `See ${context.logFile}.`,
+					lines: result.lastLines
+				});
+				context.setPodsMs(result.durationMs ?? 0);
+				mutations.push("pod install");
+				reselect();
+			}
+			if (nativeXcodeHasPackages(selected)) {
+				beforePrepare();
+				context.phase("packages", "resolving Swift package dependencies");
+				const result = await runCaptured({
+					cmd: "xcodebuild",
+					args: [
+						selected.container.flag,
+						selected.container.path,
+						"-scheme",
+						selected.scheme,
+						"-resolvePackageDependencies",
+						"-clonedSourcePackagesDirPath",
+						nativeXcodePackages(root)
+					],
+					cwd: root,
+					env: {
+						...process.env,
+						NSUnbufferedIO: "YES",
+						FORCE_COLOR: "0"
+					},
+					spawn: (file, args, opts) => getExecutor().spawn(file, args, opts),
+					now: Date.now,
+					heartbeatMs: HEARTBEAT_INTERVAL_MS,
+					onHeartbeat: context.note,
+					logWriter: context.logWriter(),
+					event: "swift_packages",
+					label: "packages"
+				});
+				if (result.error || result.code !== 0) throw new IosRecipeRefusal({
+					code: "STIM_DEPS_FAILED",
+					message: "Xcode could not resolve Swift package dependencies.",
+					remedy: `Resolve the selected scheme's packages in Xcode and inspect ${context.logFile}.`,
+					lines: result.transcript.slice(-10)
+				});
+				mutations.push("Swift package resolution");
+			}
+		},
+		async reconcile() {
+			const current = snapshot && !mutations.length ? snapshot : read();
+			if ("cacheIneligible" in current) {
+				ineligible = current.cacheIneligible;
+				snapshot = null;
+			} else snapshot = current;
+			return {
+				identity: snapshot ? identity(snapshot) : null,
+				rekeyedBy: mutations,
+				mutationLabel: mutations.join(", ")
+			};
+		},
+		async validate() {
+			if (!snapshot) return null;
+			try {
+				tools = toolchain(context.target.sdk);
+				const after = read();
+				return !("cacheIneligible" in after) && after.hash === snapshot.hash ? identity(snapshot) : null;
+			} catch {
+				return null;
+			}
+		},
+		validateExternal() {
+			throw new IosRecipeRefusal({
+				code: "STIM_BAD_ARG",
+				message: "This native Xcode integration does not use external EAS builds.",
+				remedy: "Build the native project with stim ios."
+			});
+		},
+		async materialize(path) {
+			if (context.device) {
+				const gate = gateProfileForDevice({
+					appPath: path,
+					udid: context.device.udid,
+					configuration
+				});
+				if (!gate.ok) throw new IosRecipeRefusal({
+					code: gate.code,
+					message: gate.reason,
+					remedy: gate.remedy
+				});
+			}
+			return path;
+		},
+		compile: () => buildXcode({
+			root,
+			project: selected.container,
+			scheme: selected.scheme,
+			configuration,
+			applicationTarget: {
+				name: selected.targetName,
+				projectPath: selected.targetProject.path
+			},
+			sdk: context.target.sdk,
+			udid: context.target.udid,
+			destination: context.target.destination,
+			arch: context.target.arch,
+			logWriter: context.logWriter(),
+			estimateMs: context.estimates().coldBuildMs,
+			extraArgs: nativeXcodeHasPackages(selected) ? [
+				"-clonedSourcePackagesDirPath",
+				nativeXcodePackages(root),
+				"-disableAutomaticPackageResolution"
+			] : [],
+			compilationCache: ({ derivedDataPath }) => {
+				const casPath = sharedCompilationCache();
+				const settings = compilationCacheSettings({
+					workspaceRoot: root,
+					derivedDataPath,
+					casPath,
+					xcodeMajor: parseXcodeMajor(tools?.xcode),
+					swiftVersion: parseSwiftVersion(tools?.swift),
+					swiftCacheCompatible: (!process.env.SWIFT_ENABLE_EXPLICIT_MODULES || process.env.SWIFT_ENABLE_EXPLICIT_MODULES === "YES") && !selected.projects.some((project) => [...project.objects.values()].some((entry) => {
+						if (entry.isa !== "XCBuildConfiguration" || pbxString(entry.name) !== configuration) return false;
+						const targetSettings = entry.buildSettings;
+						const explicitModules = pbxString(targetSettings?.SWIFT_ENABLE_EXPLICIT_MODULES);
+						return explicitModules !== null && explicitModules !== "YES";
+					})),
+					optimizations: context.optimizations
+				});
+				if (settings.length && context.optimizations.compilationCache) register({
+					dir: casPath,
+					name: "Xcode compilation cache",
+					prune: "atomic",
+					note: "shared Xcode compilation cache"
+				});
+				return settings;
+			}
+		}),
+		explain(rekeyedBy) {
+			if (!snapshot) return {
+				reason: skippedMissReason(ineligible ?? "Native build inputs are not cacheable"),
+				diff: null
+			};
+			return {
+				reason: explainBuildMiss({
+					root,
+					platform: "ios",
+					current: {
+						hash: snapshot.hash,
+						sources: nativeXcodeSources(snapshot)
+					},
+					rekeyedBy
+				}).reason,
+				diff: null
+			};
+		},
+		untrackedLine: () => null,
+		legacyCache: null,
+		offload: {
+			context: () => {
+				const runtime = context.target.sdk === "iphonesimulator" ? context.target.offloadRuntime() : null;
+				return {
+					runtime,
+					unsupported: context.target.offloadRefusal ?? (context.device ? "Physical native Xcode builds build here" : !context.cache.write ? "the build cache is off" : !runtime ? "no simulator runtime is available for worker selection" : !snapshot ? "the native inputs have no verified identity" : nativeTransferRefusal(repoRoot(root) ?? root, snapshot))
+				};
+			},
+			target: (runtime) => ({
+				platform: "ios",
+				native: "xcode",
+				local: {
+					...iosToolchain(root, "xcode"),
+					...context.target.hostedArchitecture ? { arch: context.target.hostedArchitecture === "x86_64" ? "x64" : "arm64" } : {}
+				},
+				runtime,
+				cocoapodsPinned: false
+			}),
+			request: (runtime) => {
+				if (!snapshot) throw new Error("Native Xcode offload needs a verified artifact input identity.");
+				return {
+					platform: "ios",
+					runtime,
+					configuration,
+					scheme: selected.scheme,
+					isExpo: false,
+					optimizations: context.optimizations,
+					native: {
+						provider: "xcode",
+						snapshot,
+						cacheKey: identity(snapshot).key,
+						arch: context.target.keyArch
+					}
+				};
+			},
+			unchanged: async () => {
+				const current = read();
+				return snapshot !== null && !("cacheIneligible" in current) && current.hash === snapshot.hash;
+			}
+		}
+	};
+}
+async function planNativeXcode(root, options) {
+	if (options.easProfile !== void 0) return { refusal: planFlagRefusal("--eas-profile") };
+	try {
+		const context = settingsContext(root);
+		const settings = resolveSettings(context);
+		const errors = settingShapeErrors(settings);
+		if (errors.length) throw new NativeXcodeError(errors.join("; "), "Correct the project settings and retry.");
+		if (remoteIosSetting(settings)) throw new NativeXcodeError("Native Xcode planning does not resolve hosted placement.", "Unset ios.remote to plan a local build, or run stim ios without --plan.");
+		const layers = DEFAULT_DEPS.settingsLayers(context);
+		const modelRefusal = deviceModelRefusal({
+			slot: options.slot ?? "default",
+			deviceTypeFlag: options.deviceType,
+			runtimeFlag: options.runtime,
+			deviceType: resolveDeviceType(options.deviceType, settings),
+			runtime: resolveRuntime(options.runtime, settings),
+			deviceTypeOrigin: DEFAULT_DEPS.settingOriginScope(layers, "ios.deviceType"),
+			runtimeOrigin: DEFAULT_DEPS.settingOriginScope(layers, "ios.runtime"),
+			physical: false,
+			remoteBackend: null,
+			listRuntimes: DEFAULT_DEPS.listIosRuntimes
+		});
+		if (modelRefusal) return { refusal: modelRefusal };
+		const configuration = resolveConfiguration(options.configuration, settings) ?? "Debug";
+		const selection = selectNativeXcodeProject(root, resolveSchemeSelection(options, settings), configuration);
+		const optimizations = resolveOptimizations(settings);
+		const architecture = simulatorBuildArch({
+			physical: false,
+			remoteArch: null,
+			hostArch: process.arch === "arm64" ? "arm64" : "x86_64",
+			configuration
+		});
+		const snapshot = nativeXcodeInputSnapshot(root, selection, {
+			sdk: "iphonesimulator",
+			architecture,
+			toolchain: toolchain("iphonesimulator"),
+			optimizations: optimizations.ios
+		}, context.repoRoot ?? root);
+		if ("cacheIneligible" in snapshot) throw new NativeXcodeError(`No reusable native artifact can be predicted: ${snapshot.cacheIneligible}.`, "Run stim ios without --plan; it can prepare dependencies and build locally without artifact caching.");
+		const key = buildCacheKey("ios", snapshot.hash, {
+			configuration,
+			scheme: selection.scheme,
+			isSimulator: true,
+			...architecture ? { arch: architecture } : {}
+		});
+		return await planCachedBuild({
+			root,
+			platform: "ios",
+			slot: options.slot ?? "default",
+			projectKey: statsProjectKey({
+				root,
+				commonDir: context.gitCommonDir,
+				repoRoot: context.repoRoot
+			}),
+			isExpo: false,
+			fingerprint: snapshot.hash,
+			sources: nativeXcodeSources(snapshot),
+			cacheKey: key,
+			cachePolicy: artifactCachePolicy(optimizations, options.buildCache !== false, false),
+			providerConfig: resolveCacheProviderConfig(context),
+			expoRemote: null
+		}, {
+			...DEFAULT_DEPS,
+			planPrebuild: () => "none",
+			note: (line) => console.error(line)
+		});
+	} catch (error) {
+		return { refusal: refusal(error) };
+	}
+}
+function nativeXcodeIosProject(root) {
+	return {
+		isExpo: false,
+		targets: [
+			"simulator",
+			"physical",
+			"hosted"
+		],
+		eas: false,
+		runtimeKind: () => "process",
+		plan: (options) => planNativeXcode(root, options),
+		bundleId: () => null,
+		schemeProblem(scheme, configuration) {
+			try {
+				selectNativeXcodeProject(root, scheme, configuration ?? "Debug");
+				return null;
+			} catch (error) {
+				return refusal(error);
+			}
+		},
+		runtime: () => iosProcessRuntime(async () => ({
+			ok: true,
+			prepared: { metroPort: null }
+		})),
+		artifact: (context) => nativeRecipe(root, context)
+	};
+}
+function nativeXcodeDoctor(root) {
+	return { inspect({ options, settings }) {
+		if (options.platform && options.platform !== "ios") return [];
+		try {
+			const selection = selectNativeXcodeProject(root, resolveSchemeSelection({}, settings), resolveConfiguration(void 0, settings) ?? "Debug");
+			const podfile = existsSync(join(root, "Podfile"));
+			return [{
+				level: "note",
+				title: "Native Xcode application",
+				detail: `${selection.scheme} (${selection.configuration}) uses native process readiness without Metro.${podfile ? " CocoaPods dependencies are prepared from the project root." : ""}`,
+				fix: null
+			}];
+		} catch (error) {
+			const problem = refusal(error);
+			return [{
+				level: "cost",
+				title: "Native Xcode selection",
+				detail: problem.message,
+				fix: problem.remedy
+			}];
+		}
+	} };
+}
+//#endregion
+export { nativeXcodeDoctor, nativeXcodeIosProject };

package/dist/{ndjson-LGZAMsqa.mjs → ndjson-GOnbyvso.mjs}

@@ -1,7 +1,7 @@
 import { dirname } from "path";
-import { LEVELS, SOURCES, levelRank, parseNdjsonLine, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
-import { closeSync, mkdirSync, openSync, writeSync } from "fs";
-import { rotateLog } from "@stim-cli/core";
+import { LEVELS, SOURCES, levelRank, parseNdjsonLine, parseNdjsonText, readNdjsonGenerations as readNdjsonGenerations$1, runId } from "@stim-cli/core/state";
+import { closeSync, openSync, writeSync } from "fs";
+import { ensurePrivateDir, rotateLog } from "@stim-cli/core";
 //#region src/ndjson.ts
 const ROTATE_CHECK_MS = 1e3;
 function formatNdjsonLine(record) {
@@ -21,8 +21,8 @@ function createNdjsonWriter(file, { truncate = false, fields = {}, maxBytes, now
 	let lastError = null;
 	let closed = false;
 	function open() {
-		mkdirSync(dirname(file), { recursive: true });
-		fd = openSync(file, freshFile ? "w" : "a");
+		ensurePrivateDir(dirname(file));
+		fd = openSync(file, freshFile ? "w" : "a", 384);
 		freshFile = false;
 	}
 	function rotateIfDue(limit) {
@@ -115,4 +115,4 @@ function stamp(record) {
 	};
 }
 //#endregion
-export { parseNdjsonLine as a, levelRank as i, SOURCES as n, readNdjsonGenerations$1 as o, createNdjsonWriter as r, LEVELS as t };
+export { parseNdjsonLine as a, levelRank as i, SOURCES as n, parseNdjsonText as o, createNdjsonWriter as r, readNdjsonGenerations$1 as s, LEVELS as t };

package/dist/offload-worker.d.mts

@@ -1,10 +1,10 @@
-import "./state-lKh8shBp.mjs";
 import { n as CcacheActivity, r as CompilationCacheActivity } from "./build-facts-DcLv2HSd.mjs";
+import "./settings-vk3mJGSm.mjs";
 import "./ndjson-Du3j0AQ9.mjs";
 import "@stim-cli/core/state";
 import { readFileSync } from "fs";
 import "@expo/fingerprint";
-import "@stim-cli/core/protocol";
+import { BuildStartParams } from "@stim-cli/core/protocol";
 //#region src/optimizations.d.ts
 interface Optimizations {
   buildCache: boolean;
@@ -41,13 +41,15 @@ interface AndroidBuildOptions {
   gradleBuildCache: boolean;
   pch: "auto" | "on" | "off";
   compilerCache: "ccache" | "none";
+  gradleRoot?: string | null;
+  module?: string | null;
 }
 //#endregion
 //#region src/offload/worker.d.ts
-/** One file of the client's checkout, as `git ls-files -co --exclude-standard` lists it. */
+/** One entry of the source transfer: a visible file of the checkout, or a native build's file or directory input. */
 interface ManifestEntry {
   path: string;
-  kind: "file" | "exec" | "link";
+  kind: "file" | "exec" | "link" | "directory";
   size: number;
   sha256: string;
 }
@@ -71,9 +73,11 @@ interface WorkerJob {
   isExpo: boolean;
   configuration: string | null;
   scheme: string | null;
+  iosProjectPath?: string | null;
   runtime: string | null;
   android: AndroidBuildOptions | null;
-  expectedFingerprint: string;
+  expectedFingerprint: string | null;
+  native?: BuildStartParams["native"];
   optimizations: Optimizations["ios"] | null;
   /** How long the client's Gradle daemon stays warm after an Android build; 0 or absent stops it when the build ends. */
   gradleDaemonIdleMs?: number;
@@ -95,7 +99,9 @@ type WorkerResult = {
     size: number;
     sha256: string;
   };
-  fingerprint: string;
+  fingerprint: string | null;
+  androidPackage?: string;
+  sourceDigest?: string;
   compilationCache: CompilationCacheActivity | CcacheActivity | Record<string, never>;
   timings: WorkerTimings;
 } | {