stim 1.17.2 → 1.19.0

package/dist/native-run-D1Q56rAD.mjs

@@ -1,158 +0,0 @@
-import { a as formatElapsed } from "./command-output-CDAIFD-8.mjs";
-import { a as updateWorkspaceState, r as readWorkspaceState, t as clearWorkspaceStateKey, v as workspaceDir } from "./workspace-state-DqcCbpE7.mjs";
-import { i as signalDeclaredSpawns, r as refuseDeclaredSpawns, t as allowDeclaredSpawns } from "./spawn-claims-D0XfSe8u.mjs";
-import { t as withWorkspaceProcessLock } from "./workspace-process-lock-2mNzOlaB.mjs";
-//#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";
-function nativeRunHolder(holder) {
-	const { command, platform, slot } = holder.details;
-	return {
-		command: typeof command === "string" ? command : null,
-		platform: typeof platform === "string" ? platform : null,
-		slot: typeof slot === "string" ? slot : "default"
-	};
-}
-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(", ")})`;
-	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") {
-		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" };
-}
-function requestNativeRunCancel(root, claimId, pid = process.pid) {
-	updateWorkspaceState(root, (state) => ({
-		...state,
-		[CANCEL_REQUEST_KEY]: {
-			claimId,
-			pid,
-			at: (/* @__PURE__ */ new Date()).toISOString()
-		}
-	}));
-}
-function cancelRequestFor(root, claimId) {
-	const request = readWorkspaceState(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 {}
-}
-let cancelled = null;
-let cancellationSignal;
-/** The active native run aborts this signal when it is cancelled. */
-function runCancellationSignal() {
-	return cancellationSignal;
-}
-/** Why this process's native run was cancelled, or null while it was not. */
-function runCancellation() {
-	return cancelled;
-}
-function cancelledFailure(platform, { code, message }) {
-	if (cancelled === null) 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 cancelOnInterrupt({ root, claim, write, exit, controller }) {
-	let signals = 0;
-	const onInterrupt = () => {
-		signals += 1;
-		if (signals > 1) {
-			exit(130);
-			return;
-		}
-		const request = cancelRequestFor(root, claim.claimId);
-		cancelled = request ? `cancelled by \`stim stop\` (pid ${request.pid})` : "cancelled by an interrupt";
-		controller.abort();
-		refuseDeclaredSpawns(`the run was ${cancelled}`);
-		const signalled = signalDeclaredSpawns("SIGINT");
-		write(signalled > 0 ? `${cancelled}; stopping the running build tool` : request ? `${cancelled}; stopping before the next build tool or install` : cancelled);
-		if (signalled === 0 && !request) exit(130);
-	};
-	process.on("SIGINT", onInterrupt);
-	return () => {
-		process.off("SIGINT", onInterrupt);
-		allowDeclaredSpawns();
-		clearNativeRunCancel(root, claim.claimId);
-	};
-}
-/**
-* 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`. The first SIGINT
-* forwards the interrupt to the running declared build tool; a run `stim stop` cancelled between build
-* tools starts no further one; a terminal interrupt with no build tool running, or a second SIGINT, exits
-* with 130 at once.
-*/
-function withNativeBuildRun(root, details, fn, { write, exit = (code) => process.exit(code) }) {
-	const notice = nativeRunWaitNotice({ write });
-	return withWorkspaceProcessLock(workspaceDir(root), NATIVE_RUN_LOCK, async (claim) => {
-		cancelled = null;
-		const controller = new AbortController();
-		cancellationSignal = controller.signal;
-		const dispose = cancelOnInterrupt({
-			root,
-			claim,
-			write,
-			exit,
-			controller
-		});
-		try {
-			return await fn(claim);
-		} finally {
-			dispose();
-			cancellationSignal = void 0;
-		}
-	}, {
-		external: true,
-		waitMs: NATIVE_RUN_WAIT_MS,
-		declareSpawns: true,
-		details: { ...details },
-		onHeld: (holder) => notice(holder)
-	});
-}
-//#endregion
-export { decideStopAction as a, nativeRunWaitNotice as c, runCancellationSignal as d, withNativeBuildRun as f, clearNativeRunCancel as i, requestNativeRunCancel as l, NATIVE_RUN_WAIT_MS as n, describeNativeRunHolder as o, cancelledFailure as r, nativeRunHolder as s, NATIVE_RUN_LOCK as t, runCancellation as u };

package/dist/preview-B-g9d7kV.mjs

@@ -1,318 +0,0 @@
-import { P as measuredDirectorySize } from "./config-D0DbpZtM.mjs";
-import { s as findProjectRoot$1 } from "./project-D47Rh0ly.mjs";
-import { M as planCacheEmptying, Q as discoverCaches, c as resolveBudget, r as enforceBudget, s as readVolumeSpace } from "./budget-DfcgFdQB.mjs";
-import { o as canonicalPath } from "./in-use-CvGOUn-x.mjs";
-import { h as listBuildLocks } from "./device-lease-DpoS36_u.mjs";
-import { n as listBuildSlots } from "./build-slots-41v_d2x9.mjs";
-import { j as readHostMemoryPressure } from "./ios-DSfnPfse.mjs";
-import { a as collectWorkspaceOutputs } from "./workspaces-Bcib97-6.mjs";
-import { t as resolveMaintenanceSettings } from "./settings-BBpMcDbD.mjs";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { buildCacheRoot, configDir, metroCacheRoot } from "@stim-cli/core";
-import { buildWorkerRoot, loadConfig, readMaintenanceState, sharedCcache, sharedCompilationCache } from "@stim-cli/core/state";
-import { cpus, freemem, loadavg, totalmem } from "node:os";
-//#region src/maintenance/measure.ts
-function measurePressure(settings, previous, now) {
-	const config = loadConfig();
-	const level = readHostMemoryPressure();
-	const availableBytes = process.platform === "darwin" ? null : freemem();
-	const warningSince = level === "warning" ? previous?.warningSince ?? now : null;
-	const pressured = settings.memoryPressureLevel !== "off" && (level === "critical" || settings.memoryPressureLevel === "warning" && warningSince !== null && now - warningSince >= settings.memoryWarningMinutes * 6e4 || availableBytes !== null && availableBytes < (settings.minAvailableMemoryGb === void 0 ? totalmem() * .1 : settings.minAvailableMemoryGb * 1024 ** 3));
-	return {
-		disk: readVolumeSpace([
-			configDir(),
-			...Object.keys(config?.projects ?? {}),
-			buildWorkerRoot(config)
-		]),
-		memory: {
-			level,
-			availableBytes,
-			pressured
-		},
-		warningSince
-	};
-}
-function sizeScanDeferred(settings) {
-	return loadavg()[0] / Math.max(1, cpus().length) > settings.maxLoadPerCore;
-}
-function cacheBlocked(entry, discovered = discoverCaches()) {
-	return planCacheEmptying([{
-		...entry,
-		note: "",
-		prune: "entries",
-		...discovered.some((cache) => canonicalPath(cache.dir) === canonicalPath(entry.dir) && cache.source === "registered") ? { source: "registered" } : {}
-	}], false)[0]?.machineGlobal ?? (entry.category === "compilation-cache" && [...listBuildLocks(), ...listBuildSlots()].some((item) => item.alive || item.unresolved) ? "a build lock or slot is live or unresolved" : void 0);
-}
-function measureSizes(now, failure) {
-	const sizes = [];
-	const outputs = collectWorkspaceOutputs({
-		olderThan: null,
-		now,
-		sizeTimeoutMs: 12e4
-	});
-	for (const entry of outputs.workspaces) {
-		if (entry.bytes === null) {
-			failure(entry.dir, entry.projectRoot ?? void 0);
-			continue;
-		}
-		sizes.push({
-			name: "workspace build outputs",
-			category: "workspace-outputs",
-			dir: entry.dir,
-			bytes: entry.bytes,
-			measuredAt: now,
-			...entry.projectRoot ? { workspace: canonicalPath(entry.projectRoot) } : {},
-			idleDays: entry.idleDays,
-			...!entry.willClear ? { blocked: entry.keptReason ?? "workspace ownership is unresolved" } : {}
-		});
-	}
-	const known = [
-		{
-			name: "shared build cache",
-			dir: buildCacheRoot(),
-			category: "build-cache"
-		},
-		{
-			name: "Metro transform caches",
-			dir: metroCacheRoot(),
-			category: "metro-cache"
-		},
-		{
-			name: "ccache",
-			dir: sharedCcache(),
-			category: "ccache"
-		},
-		{
-			name: "Swift compilation cache",
-			dir: sharedCompilationCache(),
-			category: "compilation-cache"
-		}
-	];
-	const discovered = discoverCaches();
-	for (const cache of discovered) {
-		if (cache.source !== "registered" && !canonicalPath(cache.dir).startsWith(`${canonicalPath(configDir())}/`)) continue;
-		if (cache.prune === "report-only") continue;
-		const dir = canonicalPath(cache.dir);
-		if (known.some((item) => dir === canonicalPath(item.dir) || dir.startsWith(`${canonicalPath(item.dir)}/`))) continue;
-		const category = cache.name.startsWith("Metro transform cache") ? "metro-cache" : /^(Expo build cache|native build cache|Build cache)$/.test(cache.name) ? "build-cache" : "other";
-		known.push({
-			name: cache.name,
-			dir: cache.dir,
-			category
-		});
-	}
-	for (const entry of known) {
-		if (!existsSync(entry.dir)) continue;
-		const bytes = measuredDirectorySize(entry.dir, { timeoutMs: 12e4 });
-		if (bytes === null) {
-			failure(entry.dir);
-			continue;
-		}
-		const blocked = cacheBlocked(entry, discovered);
-		sizes.push({
-			...entry,
-			bytes,
-			measuredAt: now,
-			...blocked ? { blocked } : {}
-		});
-	}
-	return sizes;
-}
-//#endregion
-//#region src/maintenance/plan.ts
-function plan({ pressure, sizes, settings, budget, diskSteps = [], protectedRoot, scoped = false, projects = [] }) {
-	const actions = [];
-	const blocked = [];
-	const skips = [];
-	const add = (action) => {
-		if (!actions.some((entry) => entry.kind === action.kind && entry.target === action.target)) actions.push(action);
-	};
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	const low = pressure?.disk.filter((disk) => disk.freeMb < floor) ?? [];
-	const reason = low.map((disk) => `free disk ${(disk.freeMb / 1024).toFixed(1)}G on ${disk.volume} under the ${(floor / 1024).toFixed(1)}G floor`).join("; ");
-	const kinds = {
-		"idle-devices": "would-shutdown-device",
-		"idle-dev-servers": "would-stop-workspace",
-		"workspace-outputs": "would-clear-outputs",
-		"stale-cache-entries": "would-trim-cache"
-	};
-	if (low.length) {
-		for (const step of diskSteps) {
-			if (scoped && step.step === "idle-devices") continue;
-			for (const target of step.targets) {
-				const workspace = projects.find((root) => root === target || target.endsWith(` in ${root}`)) ?? (step.step === "idle-dev-servers" || step.step === "workspace-outputs" ? target : void 0);
-				if (workspace === protectedRoot || target === protectedRoot) continue;
-				const size = workspace && step.step !== "idle-devices" ? sizes.find((entry) => entry.workspace === workspace && entry.category === "workspace-outputs") : void 0;
-				add({
-					kind: kinds[step.step],
-					target,
-					bytes: step.step === "workspace-outputs" ? size?.bytes ?? 0 : 0,
-					reason: `${size?.idleDays == null ? "" : `idle ${size.idleDays} days, `}${reason}`,
-					...workspace ? { workspace } : {}
-				});
-			}
-			if (step.failures) blocked.push(`Could not plan ${step.step}: ${step.failures} failures`);
-		}
-		if (actions.length === 0) blocked.push(`${reason}; no reclaimable disk targets`);
-	}
-	const caps = [
-		[
-			"workspace-outputs",
-			settings.workspaceOutputsMaxGb,
-			"would-clear-outputs"
-		],
-		[
-			"build-cache",
-			settings.buildCacheMaxGb,
-			"would-trim-cache"
-		],
-		[
-			"metro-cache",
-			settings.metroCacheMaxGb,
-			"would-trim-cache"
-		],
-		[
-			"compilation-cache",
-			settings.swiftCompilationCacheMaxGb,
-			"would-empty-cache"
-		]
-	];
-	for (const [category, capGb, kind] of caps) {
-		const entries = sizes.filter((size) => size.category === category);
-		const total = entries.reduce((sum, size) => sum + size.bytes, 0);
-		const cap = capGb * 1024 ** 3;
-		if (cap === 0 || total <= cap) continue;
-		let remaining = total;
-		const targetBytes = cap * settings.capTargetPercent / 100;
-		const why = `${category} ${(total / 1024 ** 3).toFixed(1)}G over the ${capGb}G cap; target ${(targetBytes / 1024 ** 3).toFixed(1)}G`;
-		for (const size of entries.toSorted((a, b) => (b.idleDays ?? 0) - (a.idleDays ?? 0))) {
-			if (remaining <= targetBytes) break;
-			const kept = size.workspace === protectedRoot ? "the triggering workspace is protected" : size.blocked;
-			if (kept) {
-				skips.push({
-					target: size.dir,
-					reason: kept,
-					...size.workspace ? { workspace: size.workspace } : {}
-				});
-				continue;
-			}
-			const bytes = kind === "would-trim-cache" ? Math.min(size.bytes, remaining - targetBytes) : size.bytes;
-			add({
-				kind,
-				target: size.workspace ?? size.dir,
-				bytes,
-				reason: `${!size.workspace || size.idleDays == null ? "" : `idle ${size.idleDays} days, `}${why}`,
-				...size.workspace ? { workspace: size.workspace } : {}
-			});
-			remaining -= bytes;
-		}
-		if (remaining > targetBytes) blocked.push(`${why}; eligible targets cannot reach the target`);
-	}
-	if (pressure?.memory.pressured) skips.push({
-		target: "memory",
-		reason: "memory pressure observed; stopping helpers and idle workspaces is not active in report-only mode"
-	});
-	return {
-		actions,
-		blocked,
-		skips
-	};
-}
-//#endregion
-//#region src/maintenance/preview.ts
-function triggeringRoot() {
-	return canonicalPath(findProjectRoot$1(process.cwd()) ?? join(configDir(), "maintenance", "no-project"));
-}
-async function plannedMaintenance(pressure, sizes, settings, { devices = true } = {}) {
-	const resolved = resolveBudget();
-	if (resolved.error) throw new Error(resolved.error);
-	const budget = {
-		...resolved.budget,
-		maxCommittedMemoryMb: 0,
-		maxLiveWorkspaces: 0
-	};
-	const root = triggeringRoot();
-	const floor = Math.max(budget.minFreeDiskMb, budget.hardFloorDiskMb);
-	const low = pressure?.disk.some((disk) => disk.freeMb < floor);
-	const outcome = low ? await enforceBudget({
-		root,
-		note: () => {},
-		dryRun: true,
-		budget
-	}, { volumes: () => pressure.disk }) : null;
-	if (outcome && outcome.status !== "ok") throw new Error(outcome.refusal.message);
-	const outputs = collectWorkspaceOutputs({
-		olderThan: null,
-		now: Date.now(),
-		measure: false
-	});
-	const result = plan({
-		pressure,
-		sizes: sizes.map((size) => {
-			if (size.category === "compilation-cache") return {
-				...size,
-				blocked: cacheBlocked(size)
-			};
-			if (!size.workspace) return size;
-			const current = outputs.workspaces.find((entry) => entry.projectRoot && canonicalPath(entry.projectRoot) === size.workspace);
-			return Object.assign({}, size, { blocked: current?.willClear ? void 0 : current?.keptReason ?? "workspace outputs cannot be resolved" });
-		}),
-		settings,
-		budget,
-		diskSteps: outcome?.status === "ok" ? outcome.reclaimed.filter((step) => devices || step.step !== "idle-devices") : [],
-		protectedRoot: root,
-		scoped: Boolean(process.env.STIM_HOME),
-		projects: Object.keys(loadConfig()?.projects ?? {}).map(canonicalPath)
-	});
-	if (low) result.skips.push(...outputs.workspaces.filter((entry) => !entry.willClear && entry.keptReason).map((entry) => ({
-		target: entry.dir,
-		reason: entry.keptReason,
-		workspace: entry.projectRoot ?? void 0
-	})));
-	return result;
-}
-async function previewMaintenance({ devices = true } = {}) {
-	let settings;
-	try {
-		settings = resolveMaintenanceSettings();
-		const state = readMaintenanceState();
-		if (settings.invalid && settings.mode === "off") return {
-			mode: "off",
-			pressure: null,
-			actions: [],
-			blocked: [],
-			skips: [],
-			invalid: settings.invalid,
-			note: settings.invalid
-		};
-		if (settings.mode === "off") return {
-			mode: "off",
-			pressure: null,
-			actions: [],
-			blocked: [],
-			skips: [],
-			note: "maintenance.mode is off"
-		};
-		const pressure = measurePressure(settings, state?.pressure ?? null, Date.now());
-		return {
-			...await plannedMaintenance(pressure, state?.sizes ?? [], settings, { devices }),
-			mode: settings.mode,
-			...settings.invalid ? { invalid: settings.invalid } : {},
-			pressure,
-			note: settings.invalid ?? (state === null ? "no pass has run yet; sizes have not been measured" : null)
-		};
-	} catch (error) {
-		return {
-			mode: settings?.mode ?? "off",
-			...settings?.invalid ? { invalid: settings.invalid } : {},
-			pressure: null,
-			actions: [],
-			blocked: [String(error)],
-			skips: [],
-			note: "maintenance preview failed"
-		};
-	}
-}
-//#endregion
-export { sizeScanDeferred as a, measureSizes as i, previewMaintenance as n, measurePressure as r, plannedMaintenance as t };

package/dist/process-identity-BmRm1qV0.mjs

@@ -1,12 +0,0 @@
-import { n as __exportAll, r as __reExport } from "./rolldown-runtime-BsOwBuO_.mjs";
-//#region src/ownership-claim.ts
-var ownership_claim_exports = /* @__PURE__ */ __exportAll({});
-import * as import__stim_cli_core_ownership_claim from "@stim-cli/core/ownership-claim";
-__reExport(ownership_claim_exports, import__stim_cli_core_ownership_claim);
-//#endregion
-//#region src/process-identity.ts
-var process_identity_exports = /* @__PURE__ */ __exportAll({});
-import * as import__stim_cli_core_process_identity from "@stim-cli/core/process-identity";
-__reExport(process_identity_exports, import__stim_cli_core_process_identity);
-//#endregion
-export { ownership_claim_exports as n, process_identity_exports as t };