stim 1.26.0 → 1.28.0

package/dist/{toolchain-J4J8MrAr.mjs → toolchain-mLA_km-b.mjs}

@@ -1,20 +1,288 @@
-import { D as ownership_claim_exports, _ as spawnDeclared, m as declareSpawnsOn, t as getExecutor, v as stopDeclaringSpawnsOn } from "./exec-VFRpu1iA.mjs";
-import { T as workspaceDerivedData } from "./workspace-state-pUg3_RRA.mjs";
+import { D as ownership_claim_exports, _ as spawnDeclared, b as operationState, g as signalDeclaredSpawns, h as refuseDeclaredSpawns, m as declareSpawnsOn, p as allowDeclaredSpawns, t as getExecutor, u as withWorkspaceProcessLock, v as stopDeclaringSpawnsOn, y as isTermination } from "./exec-aULwtNly.mjs";
+import { E as workspaceDir, T as workspaceDerivedData, l as withWorkspaceStateLockAsync, o as updateWorkspaceState, r as readWorkspaceState$1, t as clearWorkspaceStateKey } from "./workspace-state-kIZrdlSg.mjs";
 import { n as stripAnsi, r as waitForChild, t as createLineReader } from "./process-output-Fpl8PYi8.mjs";
-import { a as formatElapsed, l as phaseLine } from "./command-output-BF5AR2dL.mjs";
-import { a as killOnAbort } from "./operation-exec-CUZifp6Z.mjs";
-import { o as androidHome } from "./android-DTAcRwBC.mjs";
-import { d as runCancellationSignal, h as shareCompilationCache } from "./native-run-BfIDFKLH.mjs";
+import { a as formatElapsed, l as phaseLine } from "./command-output-C8R1KIvi.mjs";
+import { a as killOnAbort } from "./operation-exec-Dp4FuIGR.mjs";
+import { o as androidHome } from "./android-CsPs-7Mg.mjs";
+import { t as canonicalPath } from "./paths-BsJMoPP2.mjs";
 import { p as resolveOptimizations } from "./errors-DHm_U5gv.mjs";
-import { t as cleanLine } from "./server-expo-eQfOdydb.mjs";
+import { t as cleanLine } from "./server-expo-Ccm9zB0o.mjs";
 import { createRequire } from "node:module";
 import { createHash } from "node:crypto";
-import { existsSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
-import { basename, delimiter, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, delimiter, dirname, isAbsolute, join, posix, relative, resolve, sep } from "node:path";
 import { ambientContext, ambientEnv } from "@stim-cli/core";
 import { stimBuildDigest } from "@stim-cli/core/state";
 import { fileURLToPath } from "node:url";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+//#region src/cache/cache-claim.ts
+const LABEL = "cache";
+const POLL_MS = 500;
+const EMPTYING_WAIT_MS = 6e5;
+/**
+* The claim set guarding a cache Stim can only empty whole. It sits beside the cache's resolved directory, so emptying
+* the cache never removes it and every path that reaches the same cache names the same set; before the cache exists,
+* its resolved parent stands in for it.
+*/
+function cacheClaimRoot(dir) {
+	return `${existsSync(dir) ? canonicalPath(dir) : join(canonicalPath(dirname(dir)), basename(dir))}.claims`;
+}
+function describe(holder) {
+	const { platform, projectRoot } = holder.details;
+	const where = typeof projectRoot === "string" ? ` in ${projectRoot}` : "";
+	return holder.mode === "shared" ? `the ${typeof platform === "string" ? platform : "iOS"} build (pid ${holder.owner.pid}${where}) may be using it` : `pid ${holder.owner.pid} is emptying it`;
+}
+/** Why the cache at `dir` may be in use, from its claim set, without taking or removing any claim. */
+function cacheUser(dir) {
+	const root = cacheClaimRoot(dir);
+	const survey = (0, ownership_claim_exports.readClaimSet)(root);
+	const problem = survey.unresolved[0];
+	if (problem) return `the cache claim ${problem.path} is unresolved, so a build may be using it`;
+	const holder = survey.live[0];
+	return holder ? describe(holder) : void 0;
+}
+/**
+* Takes the exclusive claim an emptier holds while it removes the cache's contents; a string is why it cannot.
+* It never waits for a build that holds the cache.
+*/
+function claimForEmptying(dir) {
+	try {
+		const attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+			root: cacheClaimRoot(dir),
+			mode: "exclusive",
+			label: LABEL
+		});
+		if (attempt.acquired) return attempt.acquired;
+		if (attempt.pending) (0, ownership_claim_exports.releaseClaim)(attempt.pending);
+		const holder = attempt.held ?? attempt.waitingFor?.[0];
+		return holder ? describe(holder) : `its claim at ${cacheClaimRoot(dir)} could not be taken`;
+	} catch (error) {
+		if ((0, ownership_claim_exports.isClaimRefusal)(error) || (0, ownership_claim_exports.isClaimUnavailable)(error)) return error.message;
+		return `its claim at ${cacheClaimRoot(dir)} could not be taken: ${error instanceof Error ? error.message : String(error)}`;
+	}
+}
+/**
+* Takes the shared claim a build holds on the compilation cache it compiles with, waiting while an emptier holds it.
+* A claim set Stim cannot resolve, or no process identity, is a failure: the build never runs unguarded.
+*/
+async function shareCompilationCache({ dir, projectRoot, note, signal }) {
+	const started = Date.now();
+	let told = false;
+	for (;;) {
+		signal?.throwIfAborted();
+		let attempt;
+		let root = `${dir}.claims`;
+		try {
+			mkdirSync(dirname(dir), { recursive: true });
+			root = cacheClaimRoot(dir);
+			attempt = (0, ownership_claim_exports.tryAcquireClaim)({
+				root,
+				mode: "shared",
+				label: LABEL,
+				details: {
+					platform: "ios",
+					projectRoot
+				}
+			});
+		} catch (error) {
+			return { failure: (0, ownership_claim_exports.claimFailure)(error, null) ?? {
+				code: ownership_claim_exports.CLAIM_UNAVAILABLE,
+				message: `Stim could not take the compilation cache claim at ${root}: ${error instanceof Error ? error.message : String(error)}.`,
+				remedy: `Restore write access to ${dirname(root)}, then retry the same Stim command.`
+			} };
+		}
+		if (attempt.acquired) return { claim: attempt.acquired };
+		const emptier = attempt.held ? `pid ${attempt.held.owner.pid}` : "another process";
+		const waited = Date.now() - started;
+		if (waited >= EMPTYING_WAIT_MS) return { failure: {
+			code: "STIM_BUILD_FAILED",
+			message: `${emptier} has been emptying the compilation cache at ${dir} for ${formatElapsed(waited)}.`,
+			remedy: "Run the same command again once it has finished."
+		} };
+		if (!told) note(phaseLine("build", `waiting for ${emptier} to finish emptying the compilation cache at ${dir}`));
+		told = true;
+		await setTimeout$1(POLL_MS);
+	}
+}
+//#endregion
+//#region src/engine/native-run.ts
+const NATIVE_RUN_LOCK = "native-run";
+const NATIVE_RUN_WAIT_MS = 18e5;
+const WAIT_HEARTBEAT_MS = 3e4;
+const CANCEL_REQUEST_KEY = "nativeRunCancel";
+const REQUEST_POLL_MS = 250;
+function nativeRunHolder(holder) {
+	const { command, platform, slot, interrupt } = holder.details;
+	return {
+		command: typeof command === "string" ? command : null,
+		platform: typeof platform === "string" ? platform : null,
+		slot: typeof slot === "string" ? slot : "default",
+		takesSignals: interrupt === "signal"
+	};
+}
+function describeNativeRunHolder(holder, now) {
+	const { command, slot } = nativeRunHolder(holder);
+	const started = Date.parse(holder.startedAt);
+	const facts = [`pid ${holder.owner.pid}`];
+	if (Number.isFinite(started)) facts.push(`running for ${formatElapsed(now - started)}`);
+	if (command === null) return `another Stim run (${facts.join(", ")})`;
+	if (command === "build") return `an artifact build (${facts.join(", ")})`;
+	return `\`stim ${command}${slot === "default" ? "" : ` --slot ${slot}`}\` (${facts.join(", ")})`;
+}
+/**
+* Report a wait on the native-run lock: one line as soon as a holder is seen, a line for each new
+* holder, and a heartbeat every WAIT_HEARTBEAT_MS while the same holder keeps it.
+*/
+function nativeRunWaitNotice({ write, now = Date.now, describe = describeNativeRunHolder }) {
+	let claimId = null;
+	let lastAt = 0;
+	return (holder, firstLine) => {
+		const at = now();
+		if (holder.claimId !== claimId) {
+			claimId = holder.claimId;
+			lastAt = at;
+			write(firstLine ?? `waiting for ${describe(holder, at)} in this workspace to finish`);
+			return;
+		}
+		if (at - lastAt < WAIT_HEARTBEAT_MS) return;
+		lastAt = at;
+		write(`still waiting for ${describe(holder, at)}`);
+	};
+}
+/**
+* What `stop` does about the run holding the native-run lock. A build is interrupted only when the stop
+* leaves it nothing to deploy to: the whole workspace stops, the build targets the stopped slot, or the
+* stopped slot is the workspace's only device. A build for another slot that stays is left running and
+* the stop proceeds without the lock. Only an owner whose identity is proven live is signalled.
+*/
+function decideStopAction({ stopSlot, holder, ownerIdentity, deviceSlots }) {
+	if (holder.command === "macos" || holder.command === "build") {
+		if (stopSlot !== void 0) return { action: "proceed" };
+		return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+	}
+	if (holder.command !== "ios" && holder.command !== "android") return { action: "wait" };
+	if (!(stopSlot === void 0 || holder.slot === stopSlot || deviceSlots.includes(stopSlot) && deviceSlots.every((slot) => slot === stopSlot))) return { action: "proceed" };
+	return ownerIdentity === "same" ? { action: "interrupt" } : { action: "refuse" };
+}
+const requestListeners = /* @__PURE__ */ new Map();
+/**
+* Ask the run holding `claimId` to cancel: the request is written to the workspace state, where the run's watch
+* finds it, and a run in this process is told at once.
+*/
+function requestNativeRunCancel(root, claimId, pid = process.pid) {
+	updateWorkspaceState(root, (state) => ({
+		...state,
+		[CANCEL_REQUEST_KEY]: {
+			claimId,
+			pid,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		}
+	}));
+	requestListeners.get(claimId)?.();
+}
+function cancelRequestFor(root, claimId) {
+	const request = readWorkspaceState$1(root)?.[CANCEL_REQUEST_KEY];
+	if (request?.claimId !== claimId || typeof request.pid !== "number") return null;
+	return { pid: request.pid };
+}
+function clearNativeRunCancel(root, claimId) {
+	try {
+		clearWorkspaceStateKey(root, CANCEL_REQUEST_KEY, (value) => value?.claimId === claimId);
+	} catch {}
+}
+/** The active native run of `context`'s operation aborts this signal when it is cancelled. */
+function runCancellationSignal(context) {
+	return operationState(context).runSignal;
+}
+/** Why `context`'s native run was cancelled, or null while it was not. */
+function runCancellation(context) {
+	return operationState(context).cancelled;
+}
+function cancelledFailure(context, platform, { code, message }) {
+	const cancelled = runCancellation(context);
+	if (cancelled === null || code === "STIM_CLAIM_UNAVAILABLE") return null;
+	return {
+		code: "STIM_CANCELLED",
+		message: `The ${platform} run was ${cancelled} before it finished.`,
+		remedy: `Run \`stim ${platform}\` again when you want the app on a device.`,
+		lines: [`it stopped at ${code ?? "an unfinished step"}${message ? `: ${message}` : ""}`]
+	};
+}
+function cancelOnAbort({ context, root, claim, write, controller }) {
+	const state = operationState(context);
+	const cancel = () => {
+		if (controller.signal.aborted) return;
+		const request = cancelRequestFor(root, claim.claimId);
+		const cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
+		state.cancelled = cancelled;
+		state.handled = true;
+		controller.abort();
+		refuseDeclaredSpawns(context, `the run was ${cancelled}`);
+		const signalled = signalDeclaredSpawns(context, "SIGINT");
+		if (signalled > 0 || request) state.draining = true;
+		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
+	};
+	const onAbort = () => {
+		if (!isTermination(context.signal.reason)) cancel();
+	};
+	const onRequest = () => {
+		if (controller.signal.aborted || !cancelRequestFor(root, claim.claimId)) return;
+		cancel();
+		state.abortOperation?.("stop");
+	};
+	context.signal.addEventListener("abort", onAbort);
+	if (context.signal.aborted) onAbort();
+	requestListeners.set(claim.claimId, onRequest);
+	const watch = setInterval(onRequest, REQUEST_POLL_MS);
+	watch.unref();
+	return async () => {
+		clearInterval(watch);
+		requestListeners.delete(claim.claimId);
+		context.signal.removeEventListener("abort", onAbort);
+		allowDeclaredSpawns(context);
+		await withWorkspaceStateLockAsync(root, () => clearNativeRunCancel(root, claim.claimId)).catch(() => {});
+	};
+}
+/**
+* Run an `ios`, `android` or `macos` invocation under the workspace's native-run lock: the claim records the
+* command, platform and slot, and a wait for another holder is reported on `write`. An abort of `context.signal`
+* forwards an interrupt to the running declared build tool and refuses any later one; a run `stim stop` cancelled
+* stops before its next build tool or install. A `SIGTERM` abort reason is left to the caller.
+*/
+function withNativeBuildRun(context, root, details, fn, { write }) {
+	const notice = nativeRunWaitNotice({ write });
+	const state = operationState(context);
+	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
+		state.cancelled = null;
+		const controller = new AbortController();
+		state.runSignal = controller.signal;
+		const dispose = cancelOnAbort({
+			context,
+			root,
+			claim,
+			write,
+			controller
+		});
+		try {
+			return await fn(claim);
+		} finally {
+			await dispose();
+			state.runSignal = void 0;
+		}
+	}, {
+		external: true,
+		signal: context.signal,
+		waitMs: NATIVE_RUN_WAIT_MS,
+		declareSpawnsFor: context,
+		details: {
+			...details,
+			interrupt: state.takesSignals ? "signal" : "request"
+		},
+		onHeld: (holder) => notice(holder)
+	});
+}
+//#endregion
 //#region src/engine/bundler.ts
 const COCOAPODS_SPEC = /^ {4}cocoapods \(([^)\s]+)/m;
 /**
@@ -631,11 +899,12 @@ async function buildXcode({ context = ambientContext(), root, udid = null, logWr
 		derivedDataPath: dd,
 		exec: executor
 	}) : compilationCache || [];
-	const buildSettings = arch ? [
+	const debugSettings = configuration === "Debug" && sdk === "iphonesimulator" ? ["DEBUG_INFORMATION_FORMAT=dwarf"] : [];
+	const buildSettings = [
 		...cacheSettings,
-		`ARCHS=${arch}`,
-		"ONLY_ACTIVE_ARCH=YES"
-	] : cacheSettings;
+		...debugSettings,
+		...arch ? [`ARCHS=${arch}`, "ONLY_ACTIVE_ARCH=YES"] : []
+	];
 	const casPathSetting = "COMPILATION_CACHE_CAS_PATH=";
 	const casDir = cacheSettings.includes("COMPILATION_CACHE_ENABLE_CACHING=YES") ? cacheSettings.find((setting) => setting.startsWith(casPathSetting))?.slice(27) ?? null : null;
 	const args = xcodebuildArgs({
@@ -914,6 +1183,7 @@ async function buildXcode({ context = ambientContext(), root, udid = null, logWr
 //#endregion
 //#region src/engine/deps.ts
 const DEPS_ERROR = "STIM_DEPS_FAILED";
+const BUILD_MARKER = ".last_build_configuration";
 const TRANSCRIPT_LINES = 2e3;
 const MAX_POD_DIAGNOSTIC_LINES = 15;
 const POD_MARKER = /^\[!\]/;
@@ -1358,6 +1628,38 @@ function gemInstallRemedy(root, pin) {
 	const version = readRubyVersion(root);
 	return `${version ? `This repo pins ruby ${version} (.ruby-version), so put that ruby on PATH (rbenv/rvm/asdf/mise) first. ` : ""}Bundler could not install the gems ${pin.lockfile} pins, so \`bundle exec pod install\` cannot run. Run \`cd ${dirname(pin.gemfile)} && bundle install\` and fix what it reports, then run again.`;
 }
+function readBuildMarkers(podsDir) {
+	let names;
+	try {
+		names = readdirSync(podsDir);
+	} catch {
+		return [];
+	}
+	return names.flatMap((name) => {
+		const dir = join(podsDir, name);
+		try {
+			return [{
+				dir,
+				ino: statSync(dir).ino,
+				content: readFileSync(join(dir, BUILD_MARKER))
+			}];
+		} catch {
+			return [];
+		}
+	});
+}
+function restoreBuildMarkers(markers) {
+	const restored = [];
+	for (const { dir, ino, content } of markers) {
+		const file = join(dir, BUILD_MARKER);
+		try {
+			if (existsSync(file) || statSync(dir).ino !== ino) continue;
+			writeFileSync(file, content);
+			restored.push(basename(dir));
+		} catch {}
+	}
+	return restored;
+}
 async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now, heartbeatMs = HEARTBEAT_INTERVAL_MS, estimateMs = null, onHeartbeat = (line) => console.error(line), directory = join(root, "ios") } = {}) {
 	const iosDir = directory;
 	if (!existsSync(iosDir)) return {
@@ -1393,6 +1695,7 @@ async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now,
 		"install"
 	] : ["pod", "install"];
 	const command = args.join(" ");
+	const markers = readBuildMarkers(join(iosDir, "Pods"));
 	const run = await runCaptured({
 		...ctx,
 		cmd: args[0],
@@ -1403,6 +1706,8 @@ async function runPodInstall(root, logWriter, { spawnFn = null, now = Date.now,
 		label: "pods",
 		estimateMs
 	});
+	const restored = restoreBuildMarkers(markers);
+	if (restored.length) notes.push(`kept the ${BUILD_MARKER} that pod install removed from ${restored.join(", ")}`);
 	if (run.error) return {
 		...(bundler ? missingBundle(run.error, pin) : missingPod(run.error)) || {
 			failed: true,
@@ -1923,6 +2228,7 @@ function cocoapodsInstall(here) {
 }
 function cocoapodsDifference(target, worker) {
 	if (target.native || target.cocoapodsPinned) return null;
+	if (worker.os !== void 0 && worker.os !== "darwin") return null;
 	const here = target.local.cocoapods;
 	if (!worker.cocoapods) return {
 		code: "cocoapods",
@@ -1979,7 +2285,7 @@ function compareVersions(a, b) {
 function pickXcodeApp(apps, wanted) {
 	return (wanted.build ? apps.find((app) => app.build === wanted.build) : void 0) ?? (wanted.version ? apps.find((app) => app.version === wanted.version) : void 0) ?? apps.toSorted((a, b) => compareVersions(b.version, a.version))[0];
 }
-const developerDirOf = (app) => join(app.path, "Contents", "Developer");
+const developerDirOf = (app) => posix.join(app.path, "Contents", "Developer");
 function selectXcode(app, selected, worker) {
 	const commands = selected ? [] : [`sudo xcode-select -s ${shellQuote(developerDirOf(app), worker.os)}`];
 	if (app.license === false && app.firstLaunch === false) commands.push("sudo xcodebuild -license accept && sudo xcodebuild -runFirstLaunch");
@@ -2104,4 +2410,4 @@ function toolchainMismatches(target, worker) {
 	return out;
 }
 //#endregion
-export { COMPILATION_CACHE_UNAVAILABLE as A, readBundleExecutable as B, POD_MISSING_REASON as C, runCaptured as D, readRubyVersion as E, compilationCacheSettings as F, tailLines as G, resolveScheme as H, detectXcodeMajorAsync as I, bundlerPin as J, xcodebuildArgs as K, parseSwiftVersion as L, SWIFT_PREFIX_MAPPING_MIN_SWIFT as M, buildXcode as N, runPodInstall as O, compilationCacheActivityLine as P, parseXcodeMajor as R, DEPS_ERROR as S, readPodState as T, startBuildHeartbeat as U, readBundleId as V, swiftPrefixMappingSupported as W, podInstallCommand as Y, sdkDownloadDisabled as _, cocoapodsDifference as a, useJdkMajor as b, iphoneRuntimes as c, jdkMajor as d, listXcodeApps as f, parseXcodeVersionPlist as g, parseAndroidRequirements as h, availableIphone as i, HEARTBEAT_INTERVAL_MS as j, COMPILATION_CACHE_NOT_RUN as k, jdkCandidates as l, macosToolchainAsync as m, androidToolchain as n, cocoapodsInstall as o, macosToolchain as p, describeDiagnostic as q, androidToolchainAsync as r, iosToolchainAsync as s, androidRequirements as t, jdkHomes as u, toolchainMismatches as v, podsAreStale as w, workerToolchain as x, toolchainNotes as y, pickXcodeProject as z };
+export { clearNativeRunCancel as $, COMPILATION_CACHE_UNAVAILABLE as A, readBundleExecutable as B, POD_MISSING_REASON as C, runCaptured as D, readRubyVersion as E, compilationCacheSettings as F, tailLines as G, resolveScheme as H, detectXcodeMajorAsync as I, bundlerPin as J, xcodebuildArgs as K, parseSwiftVersion as L, SWIFT_PREFIX_MAPPING_MIN_SWIFT as M, buildXcode as N, runPodInstall as O, compilationCacheActivityLine as P, cancelledFailure as Q, parseXcodeMajor as R, DEPS_ERROR as S, readPodState as T, startBuildHeartbeat as U, readBundleId as V, swiftPrefixMappingSupported as W, NATIVE_RUN_LOCK as X, podInstallCommand as Y, NATIVE_RUN_WAIT_MS as Z, sdkDownloadDisabled as _, cocoapodsDifference as a, runCancellation as at, useJdkMajor as b, iphoneRuntimes as c, cacheUser as ct, jdkMajor as d, decideStopAction as et, listXcodeApps as f, parseXcodeVersionPlist as g, parseAndroidRequirements as h, availableIphone as i, requestNativeRunCancel as it, HEARTBEAT_INTERVAL_MS as j, COMPILATION_CACHE_NOT_RUN as k, jdkCandidates as l, claimForEmptying as lt, macosToolchainAsync as m, androidToolchain as n, nativeRunHolder as nt, cocoapodsInstall as o, runCancellationSignal as ot, macosToolchain as p, describeDiagnostic as q, androidToolchainAsync as r, nativeRunWaitNotice as rt, iosToolchainAsync as s, withNativeBuildRun as st, androidRequirements as t, describeNativeRunHolder as tt, jdkHomes as u, toolchainMismatches as v, podsAreStale as w, workerToolchain as x, toolchainNotes as y, pickXcodeProject as z };

package/dist/{toolchain-DoavrvIA.mjs → toolchain-qktiV8xc.mjs}

@@ -1,2 +1,2 @@
-import { m as macosToolchainAsync, p as macosToolchain } from "./toolchain-J4J8MrAr.mjs";
+import { m as macosToolchainAsync, p as macosToolchain } from "./toolchain-mLA_km-b.mjs";
 export { macosToolchain, macosToolchainAsync };

package/dist/{trigger-KVaWWNyn.mjs → trigger-DMou-X7j.mjs}

@@ -1,7 +1,7 @@
-import { t as getExecutor } from "./exec-VFRpu1iA.mjs";
+import { t as getExecutor } from "./exec-aULwtNly.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-KmieOKgN.mjs";
+import { n as windowsLauncherArgs } from "./detached-entry-BPlSaCwC.mjs";
 import { n as stampAttempt, r as due, t as capChildLog } from "./attempt-ClyJlZPT.mjs";
 import { readClaimSet } from "@stim-cli/core/ownership-claim";
 import { closeSync, openSync } from "node:fs";

package/dist/trigger-qp2ji5wE.mjs

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