stim 1.21.0 → 1.23.0

package/dist/swiftpm-macos-r_WSKlXr.mjs

@@ -0,0 +1,532 @@
+import { d as spawnDeclared, t as getExecutor, y as trackReportResource } from "./exec-DEoAhcze.mjs";
+import { i as sharedBuildCache } from "./paths-DQtTgsBf.mjs";
+import { G as resolveCacheProviderConfig, L as projectSettingsContextAsync, Nt as repoRootAsync, tt as settingValueAt } from "./settings-C7O8A6ZI.mjs";
+import { r as register } from "./cache-manifest-DSeQjt-Q.mjs";
+import { d as runCancellationSignal } from "./native-run-BUTu8T7A.mjs";
+import "./build-cache-Dv7RN200.mjs";
+import { l as artifactCachePolicy, p as resolveOptimizations } from "./errors-ccaPc4ox.mjs";
+import { l as macosToolchainAsync } from "./toolchain-CWeGJgCc.mjs";
+import { r as nativeFileDigest } from "./native-source-Y0yLhFyQ.mjs";
+import { a as validateInfoPlist, i as stageBundle, n as resolveBundleExtras, r as setBundleName, t as reidentifyBundle } from "./stage-DKNM4ZPd.mjs";
+import { t as validateMacosArtifactPlatform } from "./artifact-platform-CXcmX_j3.mjs";
+import { t as logLines } from "./run-DidHghD1.mjs";
+import { n as swiftpmArtifactInputs, r as swiftpmArtifactSnapshot, t as readSwiftpmArtifactToolchain } from "./swiftpm-artifact-inputs-DFcGsXDP.mjs";
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream, existsSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
+import { parseHostedAppManifest } from "@stim-cli/core/state";
+import { cp, lstat, mkdir, mkdtemp, open, readdir, readlink, realpath, rm, symlink, writeFile } from "node:fs/promises";
+import { buildResolveTimeoutMs, buildUploadTimeoutMs, createFilesystemFileCache, loadCacheProvider } from "@stim-cli/cache";
+import { pipeline } from "node:stream/promises";
+import { Readable } from "node:stream";
+//#region src/macos/artifact-file.ts
+const MAGIC = Buffer.from("STIMMAC1\n");
+const MAX_HEADER_BYTES = 16777216;
+const canonical = (path) => path.normalize("NFC").toLowerCase();
+async function bundleFiles(bundle, signal) {
+	const files = [];
+	const directories = [];
+	const walk = async (path) => {
+		signal.throwIfAborted();
+		const absolute = join(bundle, path);
+		const info = await lstat(absolute);
+		if (info.isDirectory()) {
+			if (path) directories.push(path);
+			for (const entry of await readdir(absolute)) await walk(path ? `${path}/${entry}` : entry);
+		} else if (info.isFile()) files.push({
+			path,
+			kind: info.mode & 73 ? "exec" : "file",
+			...await nativeFileDigest(absolute, signal)
+		});
+		else if (info.isSymbolicLink()) {
+			const bytes = Buffer.from(await readlink(absolute));
+			files.push({
+				path,
+				kind: "link",
+				size: bytes.length,
+				sha256: createHash("sha256").update(bytes).digest("hex")
+			});
+		} else throw new Error("The cached macOS bundle contains an unsupported file.");
+	};
+	await walk("");
+	const parsed = parseHostedAppManifest(files);
+	if (!parsed || directories.length > 2e4) throw new Error("The cached macOS bundle has an invalid file inventory.");
+	return {
+		files: parsed,
+		directories: directories.toSorted()
+	};
+}
+async function packMacosArtifact(bundle, key, output, signal) {
+	const { files, directories } = await bundleFiles(bundle, signal);
+	const metadata = Buffer.from(JSON.stringify({
+		key,
+		files,
+		directories
+	}));
+	if (metadata.length > MAX_HEADER_BYTES) throw new Error("The cached macOS bundle receipt is too large.");
+	const header = Buffer.alloc(MAGIC.length + 4);
+	MAGIC.copy(header);
+	header.writeUInt32BE(metadata.length, MAGIC.length);
+	const payload = async function* () {
+		yield header;
+		yield metadata;
+		for (const file of files) {
+			signal.throwIfAborted();
+			const hash = createHash("sha256");
+			let size = 0;
+			const path = join(bundle, file.path);
+			const input = file.kind === "link" ? [Buffer.from(await readlink(path))] : createReadStream(path, { signal });
+			for await (const bytes of input) {
+				hash.update(bytes);
+				size += bytes.length;
+				yield bytes;
+			}
+			if (size !== file.size || hash.digest("hex") !== file.sha256) throw new Error("The macOS bundle changed while its cache entry was packed.");
+		}
+	};
+	await pipeline(Readable.from(payload()), createWriteStream(output, {
+		flags: "wx",
+		mode: 384
+	}), { signal });
+}
+async function readExactly(file, size, position, signal) {
+	const bytes = Buffer.alloc(size);
+	let offset = 0;
+	while (offset < size) {
+		signal.throwIfAborted();
+		const read = await file.read(bytes, offset, size - offset, position + offset);
+		if (!read.bytesRead) throw new Error("The cached macOS entry is truncated.");
+		offset += read.bytesRead;
+	}
+	return bytes;
+}
+async function unpackMacosArtifact(source, key, bundle, signal) {
+	signal.throwIfAborted();
+	const file = await open(source, "r");
+	try {
+		const header = await readExactly(file, MAGIC.length + 4, 0, signal);
+		const size = header.readUInt32BE(MAGIC.length);
+		if (!header.subarray(0, MAGIC.length).equals(MAGIC) || size === 0 || size > MAX_HEADER_BYTES) throw new Error("The cached macOS entry has an unsupported header.");
+		const metadata = JSON.parse((await readExactly(file, size, header.length, signal)).toString("utf8"));
+		const files = parseHostedAppManifest(metadata?.files);
+		if (metadata?.key !== key || !files) throw new Error("The cached macOS entry has an invalid identity or inventory.");
+		const directories = metadata.directories;
+		if (!Array.isArray(directories) || directories.length > 2e4 || !directories.every((path) => typeof path === "string" && path.length > 0 && path.length <= 1024 && !/[\\\0\r\n]/.test(path) && path.split("/").every((part) => part && part !== "." && part !== ".."))) throw new Error("The cached macOS entry has invalid directories.");
+		const filePaths = new Set(files.map((entry) => canonical(entry.path)));
+		for (const path of directories) {
+			let ancestor = canonical(path);
+			while (ancestor !== ".") {
+				if (filePaths.has(ancestor)) throw new Error("A cached macOS directory overlaps a file or link.");
+				ancestor = posix.dirname(ancestor);
+			}
+		}
+		let position = header.length + size;
+		if ((await file.stat()).size !== position + files.reduce((sum, entry) => sum + entry.size, 0)) throw new Error("The cached macOS entry has an invalid payload length.");
+		await mkdir(bundle, { mode: 448 });
+		for (const path of directories) {
+			signal.throwIfAborted();
+			await mkdir(join(bundle, path), {
+				recursive: true,
+				mode: 493
+			});
+		}
+		const links = [];
+		for (const entry of files) {
+			signal.throwIfAborted();
+			const path = join(bundle, entry.path);
+			await mkdir(dirname(path), {
+				recursive: true,
+				mode: 448
+			});
+			if (entry.kind === "link") {
+				const bytes = await readExactly(file, entry.size, position, signal);
+				if (createHash("sha256").update(bytes).digest("hex") !== entry.sha256) throw new Error("A cached macOS link differs from its digest.");
+				const target = bytes.toString("utf8");
+				const destination = posix.normalize(posix.join(posix.dirname(entry.path), target));
+				if (!target || !Buffer.from(target).equals(bytes) || /[\\\0\r\n]/.test(target) || posix.isAbsolute(target) || destination === "." || destination === ".." || destination.startsWith("../") || entry.path.startsWith(`${destination}/`)) throw new Error("A cached macOS link leaves its bundle or forms an ancestor cycle.");
+				links.push({
+					path,
+					target
+				});
+			} else {
+				const hash = createHash("sha256");
+				if (entry.size === 0) await writeFile(path, "", {
+					flag: "wx",
+					mode: entry.kind === "exec" ? 493 : 420,
+					signal
+				});
+				else {
+					const bytes = async function* () {
+						for await (const chunk of file.createReadStream({
+							start: position,
+							end: position + entry.size - 1,
+							autoClose: false
+						})) {
+							signal.throwIfAborted();
+							hash.update(chunk);
+							yield chunk;
+						}
+					};
+					await pipeline(Readable.from(bytes()), createWriteStream(path, {
+						flags: "wx",
+						mode: entry.kind === "exec" ? 493 : 420
+					}), { signal });
+				}
+				if (hash.digest("hex") !== entry.sha256) throw new Error("A cached macOS file differs from its digest.");
+			}
+			position += entry.size;
+		}
+		for (const link of links) await symlink(link.target, link.path);
+		const root = await realpath(bundle);
+		for (const link of links) {
+			signal.throwIfAborted();
+			const path = relative(root, await realpath(link.path));
+			if (isAbsolute(path) || path === ".." || path.startsWith(`..${sep}`)) throw new Error("A cached macOS link leaves its bundle.");
+		}
+	} finally {
+		await file.close();
+	}
+}
+//#endregion
+//#region src/macos/artifact-cache.ts
+async function providerCall(call, timeoutMs, context, directory, signal) {
+	signal.throwIfAborted();
+	const controller = new AbortController();
+	const failure = Object.assign(/* @__PURE__ */ new Error(`SwiftPM cache provider cleanup did not finish within 35 seconds. Retained ${directory}.`), {
+		code: "STIM_CLAIM_UNAVAILABLE",
+		reportCleanup: true,
+		remedy: "Confirm that the provider has stopped using the retained directory before removing it and retrying."
+	});
+	const pending = Promise.resolve().then(() => {
+		controller.signal.throwIfAborted();
+		return call(controller.signal);
+	}).then((value) => ({ value }), (error) => ({ error }));
+	let close;
+	const closed = new Promise((settleClosed) => {
+		close = settleClosed;
+	});
+	let cleanup;
+	const finish = () => cleanup ??= (async () => {
+		let timer;
+		if (!await Promise.race([pending.then(() => true), new Promise((settleDrain) => {
+			timer = setTimeout(() => settleDrain(false), 35e3);
+		})]).finally(() => clearTimeout(timer))) throw failure;
+		const result = await pending;
+		if ("error" in result && result.error instanceof Error && "reportCleanup" in result.error) throw result.error;
+	})().finally(() => close());
+	let notifyAbort;
+	const aborted = new Promise((settleAbort) => {
+		notifyAbort = () => settleAbort({ aborted: true });
+	});
+	const childAborted = () => notifyAbort();
+	controller.signal.addEventListener("abort", childAborted, { once: true });
+	const abort = () => controller.abort(signal.reason);
+	signal.addEventListener("abort", abort, { once: true });
+	trackReportResource(context, closed, finish, signal, failure);
+	const deadline = setTimeout(() => controller.abort(), timeoutMs);
+	if (signal.aborted) abort();
+	const outcome = await Promise.race([pending, aborted]);
+	clearTimeout(deadline);
+	signal.removeEventListener("abort", abort);
+	controller.signal.removeEventListener("abort", childAborted);
+	await finish();
+	signal.throwIfAborted();
+	if ("aborted" in outcome) throw new Error("SwiftPM cache provider timed out.");
+	if ("error" in outcome) throw outcome.error;
+	return outcome.value;
+}
+const fileKey = (key) => `swiftpm/v1/${key}`;
+async function contained(path, directory) {
+	const rel = relative(await realpath(directory), await realpath(path));
+	if (!rel || isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`) || !(await lstat(path)).isFile()) throw new Error("The shared SwiftPM cache file is outside its download directory or is not a regular file.");
+}
+function swiftpmArtifactCache(context, root, settings, recipe, build) {
+	const declaration = settingValueAt(settings, "macos.artifactInputs");
+	if (!declaration) return void 0;
+	const policy = artifactCachePolicy(resolveOptimizations(settings, context.env), true, false);
+	if (!policy.read) return void 0;
+	const activeSignal = () => runCancellationSignal(context) ?? context.signal;
+	const localRoot = sharedBuildCache();
+	const local = createFilesystemFileCache(join(localRoot, "macos"));
+	const storeLocal = async (key, sourcePath, signal) => {
+		register({
+			dir: localRoot,
+			registeredBy: root,
+			name: "Build cache",
+			prune: "entries",
+			entriesDepth: 2,
+			note: "completed native artifacts keyed on build inputs"
+		});
+		await local.store({
+			key: fileKey(key),
+			sourcePath,
+			overwrite: true,
+			signal
+		});
+	};
+	let provider;
+	const shared = () => provider ??= (async () => {
+		const signal = activeSignal();
+		if (!policy.remote) return null;
+		const settingsContext = await projectSettingsContextAsync(root, void 0, {
+			env: context.env,
+			signal,
+			declareFor: context
+		});
+		const loaded = await loadCacheProvider({
+			projectRoot: root,
+			config: resolveCacheProviderConfig(settingsContext),
+			env: context.env
+		});
+		if (loaded.unavailable) throw new Error(loaded.unavailable);
+		return loaded.provider?.files ?? null;
+	})();
+	const unpack = async (path, key, directory) => {
+		const signal = activeSignal();
+		const bundle = join(directory, "Cached.app");
+		await unpackMacosArtifact(path, key, bundle, signal);
+		await recipe.validateFetched(bundle, recipe.bundleId);
+		await validateMacosArtifactPlatform(context, bundle, recipe.product, signal);
+		return bundle;
+	};
+	const identity = async () => {
+		const signal = activeSignal();
+		return swiftpmArtifactSnapshot(root, declaration, build, await readSwiftpmArtifactToolchain(context, signal, root), context.env, signal);
+	};
+	return {
+		peer: () => policy.remote ? {
+			inputs: swiftpmArtifactInputs(declaration),
+			write: policy.write
+		} : null,
+		identity,
+		async has(key) {
+			const signal = activeSignal();
+			if (!await local.stat({
+				key: fileKey(key),
+				signal
+			})) return false;
+			const directory = await mkdtemp(join(tmpdir(), "stim-macos-cache-plan-"));
+			let retainDirectory = false;
+			try {
+				const source = await local.resolve({
+					key: fileKey(key),
+					destinationDir: directory,
+					signal
+				});
+				if (!source) return false;
+				await unpack(source, key, directory);
+				return true;
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) {
+					retainDirectory = true;
+					throw error;
+				}
+				signal.throwIfAborted();
+				return false;
+			} finally {
+				if (!retainDirectory) await rm(directory, {
+					recursive: true,
+					force: true
+				});
+			}
+		},
+		async restore(key, directory) {
+			const signal = activeSignal();
+			await mkdir(directory, { recursive: true });
+			const cached = await local.resolve({
+				key: fileKey(key),
+				destinationDir: directory,
+				signal
+			});
+			if (cached) try {
+				return {
+					bundle: await unpack(cached, key, directory),
+					tier: "local"
+				};
+			} catch (error) {
+				if (error instanceof Error && "reportCleanup" in error) throw error;
+				signal.throwIfAborted();
+				await rm(join(directory, "Cached.app"), {
+					recursive: true,
+					force: true
+				});
+			}
+			const files = await shared();
+			if (!files) return null;
+			const result = await providerCall((childSignal) => files.resolve({
+				key: fileKey(key),
+				destinationDir: directory,
+				signal: childSignal
+			}), buildResolveTimeoutMs(context.env), context, directory, signal);
+			signal.throwIfAborted();
+			if (!result) return null;
+			await contained(result, directory);
+			const bundle = await unpack(result, key, directory);
+			await storeLocal(key, result, signal);
+			return {
+				bundle,
+				tier: "provider"
+			};
+		},
+		async store(key, bundle, directory) {
+			const signal = activeSignal();
+			const canonical = join(directory, "Canonical.app");
+			await cp(bundle, canonical, {
+				recursive: true,
+				verbatimSymlinks: true,
+				filter: () => {
+					signal.throwIfAborted();
+					return true;
+				}
+			});
+			await cp(resolve(root, build.infoPlist), join(canonical, "Contents", "Info.plist"));
+			await reidentifyBundle(context, canonical, recipe.bundleId);
+			await recipe.validateFetched(canonical, recipe.bundleId);
+			const sourcePath = join(directory, "artifact.cache");
+			await packMacosArtifact(canonical, key, sourcePath, signal);
+			if ((await identity()).key !== key) throw new Error("SwiftPM inputs changed while the cache entry was packed.");
+			await storeLocal(key, sourcePath, signal);
+			const files = await shared();
+			if (!files) return;
+			await providerCall((childSignal) => files.store({
+				key: fileKey(key),
+				sourcePath,
+				overwrite: true,
+				signal: childSignal
+			}), buildUploadTimeoutMs(context.env), context, directory, signal);
+			signal.throwIfAborted();
+		}
+	};
+}
+//#endregion
+//#region src/integrations/swiftpm-macos.ts
+function swiftpmMacosProject(root) {
+	return { async prepare(context, settings) {
+		const macos = settings.macos;
+		if (!macos?.product || !macos.infoPlist) throw Object.assign(/* @__PURE__ */ new Error("Set macos.product and macos.infoPlist explicitly in .stim.json. See stim guide macos."), { code: "STIM_BAD_ARG" });
+		const { product, infoPlist } = macos;
+		const { bundleId } = await validateInfoPlist(context, root, product, infoPlist);
+		const repository = realpathSync(await repoRootAsync(root, {
+			env: context.env,
+			signal: context.signal
+		}) ?? root);
+		const extras = resolveBundleExtras(root, repository, macos.resources, macos.assetCatalog);
+		const recipe = {
+			product,
+			arguments: macos.arguments ?? [],
+			bundleId,
+			async compile({ scratch, writer, note }) {
+				await tool(context, root, [
+					"build",
+					"-c",
+					"debug",
+					"--product",
+					product,
+					"--scratch-path",
+					scratch,
+					"--jobs",
+					"2"
+				], writer, note);
+				return tool(context, root, [
+					"build",
+					"-c",
+					"debug",
+					"--scratch-path",
+					scratch,
+					"--show-bin-path"
+				], writer, () => {}, true);
+			},
+			stage: (bin, bundle, id, displayName) => stageBundle(context, root, product, infoPlist, bin, bundle, id, extras, displayName),
+			async validateFetched(bundle, id, displayName) {
+				const executable = join(bundle, "Contents", "MacOS", product);
+				const plist = JSON.parse(await getExecutor().runFileAsync("plutil", [
+					"-convert",
+					"json",
+					"-o",
+					"-",
+					join(bundle, "Contents", "Info.plist")
+				], {
+					timeoutMs: 1e4,
+					declareFor: context
+				}));
+				if (plist.CFBundleIdentifier !== id || plist.CFBundleExecutable !== product || !existsSync(executable)) throw new Error("The fetched macOS bundle does not match the requested identity and executable.");
+				for (const destination of [...Object.keys(extras.resources), ...extras.assetCatalog ? ["Assets.car"] : []]) if (!existsSync(join(bundle, "Contents", "Resources", destination))) throw new Error(`The fetched macOS bundle lacks declared resource ${destination}.`);
+				if (displayName !== void 0) {
+					await setBundleName(context, join(bundle, "Contents", "Info.plist"), displayName);
+					await getExecutor().runFileAsync("codesign", [
+						"--force",
+						"--sign",
+						"-",
+						bundle
+					], {
+						timeoutMs: "unbounded",
+						declareFor: context
+					});
+				}
+				await getExecutor().runFileAsync("codesign", [
+					"--verify",
+					"--strict",
+					bundle
+				], {
+					timeoutMs: "unbounded",
+					declareFor: context
+				});
+			},
+			offload: {
+				target: async () => ({
+					platform: "macos",
+					local: await macosToolchainAsync()
+				}),
+				request: (id) => ({
+					platform: "macos",
+					product,
+					infoPlist: relative(root, resolve(root, infoPlist)),
+					bundleId: id,
+					resources: Object.fromEntries(Object.entries(extras.resources).map(([destination, source]) => [destination, relative(repository, source)])),
+					assetCatalog: extras.assetCatalog ? relative(repository, extras.assetCatalog) : null
+				})
+			}
+		};
+		recipe.cache = swiftpmArtifactCache(context, root, settings, recipe, {
+			product,
+			infoPlist,
+			resources: Object.fromEntries(Object.entries(extras.resources).map(([destination, source]) => [destination, relative(root, source)])),
+			assetCatalog: extras.assetCatalog ? relative(root, extras.assetCatalog) : null
+		});
+		return recipe;
+	} };
+}
+async function tool(context, root, args, writer, note, capture = false) {
+	const child = spawnDeclared(context, () => getExecutor().spawn("swift", args, {
+		cwd: root,
+		detached: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	}));
+	let stdout = "";
+	child.stdout?.on("data", (chunk) => {
+		if (capture) stdout += chunk.toString("utf8");
+	});
+	const write = (msg) => {
+		writer.write({
+			src: "build",
+			platform: "macos",
+			level: "debug",
+			msg
+		});
+		note(msg);
+	};
+	if (child.stdout) logLines(child.stdout, write);
+	if (child.stderr) logLines(child.stderr, write);
+	await new Promise((done, reject) => {
+		child.once("error", reject);
+		child.once("close", (code) => code === 0 ? done() : reject(/* @__PURE__ */ new Error(`swift ${args[0]} failed (${code}). See stim logs --source build.`)));
+	});
+	return stdout.trim();
+}
+//#endregion
+export { swiftpmMacosProject };

package/dist/{toolchain-Hp9sCpK4.mjs → toolchain-CWeGJgCc.mjs}

@@ -1,8 +1,8 @@
-import { s as spawnDeclared, t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { d as spawnDeclared, t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { qt as killOnAbort } from "./settings-CsJDEXgK.mjs";
-import { o as androidHome } from "./android-DUYkNF4u.mjs";
-import { b as bundlerPin, h as startBuildHeartbeat, r as HEARTBEAT_INTERVAL_MS } from "./xcode-Zlx3qjEs.mjs";
+import { a as killOnAbort } from "./operation-exec-BW0em61G.mjs";
+import { o as androidHome } from "./android-C7sVmyI9.mjs";
+import { b as bundlerPin, h as startBuildHeartbeat, r as HEARTBEAT_INTERVAL_MS } from "./xcode-iQnROM5o.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
@@ -727,7 +727,10 @@ function androidRequirements(projectRoot) {
 function iphoneRuntimes(listed) {
 	const devices = listed?.devices;
 	if (!devices || typeof devices !== "object") return [];
-	return Object.entries(devices).filter(([, list]) => (Array.isArray(list) ? list : []).some((device) => device.isAvailable !== false && typeof device.name === "string" && device.name.startsWith("iPhone"))).map(([runtime]) => runtime).toSorted();
+	return Object.entries(devices).filter(([, list]) => (Array.isArray(list) ? list : []).some(availableIphone)).map(([runtime]) => runtime).toSorted();
+}
+function availableIphone(device) {
+	return device.isAvailable === true && typeof device.deviceTypeIdentifier === "string" && device.deviceTypeIdentifier.startsWith("com.apple.CoreSimulator.SimDeviceType.iPhone-");
 }
 function listDir(path) {
 	try {
@@ -870,4 +873,4 @@ function toolchainMismatches(target, worker) {
 	return out;
 }
 //#endregion
-export { runPodInstall as _, iphoneRuntimes as a, macosToolchainAsync as c, workerToolchain as d, DEPS_ERROR as f, runCaptured as g, readRubyVersion as h, iosToolchainAsync as i, parseAndroidRequirements as l, readPodState as m, androidToolchain as n, jdkMajor as o, podsAreStale as p, androidToolchainAsync as r, macosToolchain as s, androidRequirements as t, toolchainMismatches as u };
+export { runCaptured as _, iosToolchainAsync as a, macosToolchain as c, toolchainMismatches as d, workerToolchain as f, readRubyVersion as g, readPodState as h, availableIphone as i, macosToolchainAsync as l, podsAreStale as m, androidToolchain as n, iphoneRuntimes as o, DEPS_ERROR as p, androidToolchainAsync as r, jdkMajor as s, androidRequirements as t, parseAndroidRequirements as u, runPodInstall as v };

package/dist/toolchain-GVgnf8d1.mjs

@@ -0,0 +1,2 @@
+import { c as macosToolchain, l as macosToolchainAsync } from "./toolchain-CWeGJgCc.mjs";
+export { macosToolchain, macosToolchainAsync };

package/dist/{trigger-BAahxUPq.mjs → trigger-Cbyc41d_.mjs}

@@ -1,11 +1,11 @@
-import { t as getExecutor } from "./exec-_UbtCQcG.mjs";
+import { t as getExecutor } from "./exec-DEoAhcze.mjs";
 import { t as resolveMaintenanceSettings } from "./settings-Djl-mpjX.mjs";
 import { t as spawnEntry } from "./spawn-entry-jw19m8Nl.mjs";
-import { n as windowsLauncherArgs } from "./detached-entry-DFRyG1_o.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-BwNEtIrP.mjs";
 import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-DW-mQqM7.mjs";
+import { readClaimSet } from "@stim-cli/core/ownership-claim";
 import { closeSync, openSync } from "node:fs";
 import { maintenanceChildLogFile, maintenanceRunClaims, readMaintenanceAttempt, readMaintenanceState } from "@stim-cli/core/state";
-import { readClaimSet } from "@stim-cli/core/ownership-claim";
 //#region src/maintenance/trigger.ts
 const WARNING_FRESH_MS = 6e5;
 function warnCriticalDisk() {

package/dist/trigger-yb_nFzPF.mjs

@@ -0,0 +1,2 @@
+import { t as triggerMaintenance } from "./trigger-Cbyc41d_.mjs";
+export { triggerMaintenance };