stim 1.14.0 → 1.15.0

package/dist/stats-CX1Z8Tca.mjs

@@ -1,368 +0,0 @@
-import { E as withConfigLock, d as getConfigDir } from "./config-lvc7d3C2.mjs";
-import { readFileSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, relative, resolve } from "node:path";
-const PLATFORMS = ["ios", "android"];
-const OUTCOMES = ["hit", "cold"];
-function statsFile() {
-	return join(getConfigDir(), "stats.json");
-}
-function emptyStats() {
-	return {
-		version: 1,
-		machine: {},
-		projects: {}
-	};
-}
-function statsProjectKey({ root, commonDir, repoRoot }) {
-	if (commonDir && repoRoot && basename(commonDir) === ".git") return canonical(join(dirname(commonDir), relative(repoRoot, root)));
-	return canonical(root);
-}
-function updateStats(record, run, now) {
-	const at = new Date(now).toISOString();
-	const durationMs = wholeMs(run.durationMs);
-	const phases = {
-		coldBuildMs: wholeMs(run.coldBuildMs),
-		podsMs: wholeMs(run.podsMs)
-	};
-	const projects = { ...record.projects };
-	const scope = { ...projects[run.projectKey] };
-	const machine = { ...record.machine };
-	const before = scope[run.platform] ?? null;
-	const credit = creditMs(before, run, durationMs);
-	scope[run.platform] = applyRun(before, run, {
-		at,
-		durationMs,
-		credit,
-		phases
-	});
-	projects[run.projectKey] = scope;
-	machine[run.platform] = applyRun(machine[run.platform] ?? null, run, {
-		at,
-		durationMs,
-		credit,
-		phases
-	});
-	const history = { ...record.history };
-	if (run.phases && !run.failed && !run.waitedForBuild) {
-		const outcome = isHit(run.cacheHit) ? "hit" : "cold";
-		const project = { ...history[run.projectKey] };
-		const lists = { ...project[run.platform] };
-		const sample = {
-			at,
-			durationMs,
-			phases: wholePhases(run.phases)
-		};
-		lists[outcome] = [...lists[outcome] ?? [], sample].slice(-10);
-		project[run.platform] = lists;
-		history[run.projectKey] = project;
-	}
-	return {
-		version: 1,
-		machine,
-		projects,
-		...Object.keys(history).length ? { history } : {}
-	};
-}
-function readStats() {
-	const path = statsFile();
-	let text;
-	try {
-		text = readFileSync(path, "utf-8");
-	} catch {
-		return {
-			record: null,
-			note: null
-		};
-	}
-	const parsed = parseRecord(text);
-	if (!parsed) return {
-		record: null,
-		note: `Run statistics at ${path} could not be read; the next ios or android run moves them aside and starts a new file.`
-	};
-	if (parsed.version > 1) return {
-		record: null,
-		note: `Run statistics at ${path} are version ${parsed.version}, which this Stim does not understand, so none are shown.`
-	};
-	return {
-		record: normalize(parsed),
-		note: null
-	};
-}
-function projectEstimates(record, projectKey, platform) {
-	const bucket = record?.projects?.[projectKey]?.[platform] ?? null;
-	return {
-		coldBuildMs: positive(bucket?.lastColdBuildMs),
-		podsMs: positive(bucket?.lastPodsMs)
-	};
-}
-function readRunEstimates({ projectKey, platform, read = readStats }) {
-	if (!projectKey) return {
-		coldBuildMs: null,
-		podsMs: null
-	};
-	try {
-		return projectEstimates(read().record, projectKey, platform);
-	} catch {
-		return {
-			coldBuildMs: null,
-			podsMs: null
-		};
-	}
-}
-function recordRunStats(run, now) {
-	return withConfigLock(() => {
-		const path = statsFile();
-		const loaded = loadForUpdate(path, now);
-		if (loaded.newerVersion !== null) return {
-			recorded: false,
-			note: `Run statistics at ${path} are version ${loaded.newerVersion}, which this Stim does not understand, so this run was not recorded.`
-		};
-		writeStats(path, updateStats(loaded.record, run, now));
-		return {
-			recorded: true,
-			note: loaded.note
-		};
-	});
-}
-function createRunRecorder({ platform, write, now, note, phases }) {
-	let projectKey = null;
-	let cacheKey = null;
-	let coldBuildMs = 0;
-	let podsMs = 0;
-	let recorded = false;
-	return {
-		setProject(key) {
-			projectKey = key;
-		},
-		setCacheKey(key) {
-			cacheKey = key;
-		},
-		setBuildMs(ms) {
-			coldBuildMs = wholeMs(ms);
-		},
-		setPodsMs(ms) {
-			podsMs = wholeMs(ms);
-		},
-		record({ failed, cacheHit = false, waited = null, durationMs }) {
-			if (!projectKey || !cacheKey || recorded) return;
-			recorded = true;
-			const ran = failed ? {} : phases?.() ?? {};
-			try {
-				const outcome = write({
-					platform,
-					projectKey,
-					failed,
-					cacheHit,
-					waitedForBuild: Boolean(waited),
-					durationMs,
-					...coldBuildMs > 0 ? { coldBuildMs } : {},
-					...podsMs > 0 ? { podsMs } : {},
-					...Object.keys(ran).length ? { phases: ran } : {}
-				}, now());
-				if (outcome?.note) note(outcome.note);
-			} catch (error) {
-				note(`Run statistics could not be recorded: ${error?.message || error}`);
-			}
-		}
-	};
-}
-function loadForUpdate(path, now) {
-	let text;
-	try {
-		text = readFileSync(path, "utf-8");
-	} catch {
-		return {
-			record: emptyStats(),
-			note: null,
-			newerVersion: null
-		};
-	}
-	const parsed = parseRecord(text);
-	if (!parsed) {
-		const aside = `${path}.corrupt-${now}`;
-		renameSync(path, aside);
-		return {
-			record: emptyStats(),
-			note: `Run statistics at ${path} could not be read, so they were moved to ${aside} and a new file was started.`,
-			newerVersion: null
-		};
-	}
-	if (parsed.version > 1) return {
-		record: emptyStats(),
-		note: null,
-		newerVersion: parsed.version
-	};
-	return {
-		record: normalize(parsed),
-		note: null,
-		newerVersion: null
-	};
-}
-function writeStats(path, record) {
-	const tmp = `${path}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
-	writeFileSync(tmp, `${JSON.stringify(record)}\n`);
-	try {
-		renameSync(tmp, path);
-	} catch (error) {
-		rmSync(tmp, { force: true });
-		throw error;
-	}
-}
-function parseRecord(text) {
-	let parsed;
-	try {
-		parsed = JSON.parse(text);
-	} catch {
-		return null;
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
-	const version = parsed.version;
-	if (typeof version !== "number" || !Number.isInteger(version)) return null;
-	return parsed;
-}
-function normalize(record) {
-	const projects = {};
-	const source = record.projects;
-	if (source && typeof source === "object" && !Array.isArray(source)) for (const [key, scope] of Object.entries(source)) projects[key] = normalizeScope(scope);
-	const history = {};
-	if (isObject(record.history)) for (const [key, scope] of Object.entries(record.history)) {
-		const normalized = normalizeHistory(scope);
-		if (Object.keys(normalized).length) history[key] = normalized;
-	}
-	return {
-		version: 1,
-		machine: normalizeScope(record.machine),
-		projects,
-		...Object.keys(history).length ? { history } : {}
-	};
-}
-function isObject(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeHistory(scope) {
-	const history = {};
-	if (!isObject(scope)) return history;
-	for (const platform of PLATFORMS) {
-		const lists = scope[platform];
-		if (!isObject(lists)) continue;
-		const normalized = {};
-		for (const outcome of OUTCOMES) {
-			const samples = lists[outcome];
-			if (!Array.isArray(samples)) continue;
-			const kept = samples.filter(isObject).flatMap((sample) => {
-				const durationMs = wholeMs(sample.durationMs);
-				if (durationMs <= 0) return [];
-				return [{
-					at: timestamp(sample.at),
-					durationMs,
-					phases: wholePhases(sample.phases)
-				}];
-			});
-			if (kept.length) normalized[outcome] = kept.slice(-10);
-		}
-		if (Object.keys(normalized).length) history[platform] = normalized;
-	}
-	return history;
-}
-function wholePhases(phases) {
-	const out = {};
-	if (!isObject(phases)) return out;
-	for (const [name, ms] of Object.entries(phases)) {
-		const value = Number(ms);
-		if (Number.isFinite(value) && value >= 0) out[name] = Math.round(value);
-	}
-	return out;
-}
-function normalizeScope(scope) {
-	const normalized = {};
-	if (!scope || typeof scope !== "object" || Array.isArray(scope)) return normalized;
-	for (const platform of PLATFORMS) {
-		const bucket = scope[platform];
-		if (bucket && typeof bucket === "object" && !Array.isArray(bucket)) normalized[platform] = normalizeBucket(bucket);
-	}
-	return normalized;
-}
-function normalizeBucket(bucket) {
-	return {
-		runs: count(bucket.runs),
-		failed: count(bucket.failed),
-		hits: count(bucket.hits),
-		misses: count(bucket.misses),
-		coldRuns: count(bucket.coldRuns),
-		coldRunMs: count(bucket.coldRunMs),
-		hitRuns: count(bucket.hitRuns),
-		hitRunMs: count(bucket.hitRunMs),
-		timeSavedMs: count(bucket.timeSavedMs),
-		firstRunAt: timestamp(bucket.firstRunAt),
-		lastRunAt: timestamp(bucket.lastRunAt),
-		...count(bucket.lastColdBuildMs) > 0 ? { lastColdBuildMs: count(bucket.lastColdBuildMs) } : {},
-		...count(bucket.lastPodsMs) > 0 ? { lastPodsMs: count(bucket.lastPodsMs) } : {}
-	};
-}
-function applyRun(bucket, run, { at, durationMs, credit, phases }) {
-	const next = bucket ? { ...bucket } : {
-		runs: 0,
-		failed: 0,
-		hits: 0,
-		misses: 0,
-		coldRuns: 0,
-		coldRunMs: 0,
-		hitRuns: 0,
-		hitRunMs: 0,
-		timeSavedMs: 0,
-		firstRunAt: at,
-		lastRunAt: at
-	};
-	next.runs += 1;
-	next.lastRunAt = at;
-	if (phases.coldBuildMs > 0) next.lastColdBuildMs = phases.coldBuildMs;
-	if (phases.podsMs > 0) next.lastPodsMs = phases.podsMs;
-	if (run.failed) {
-		next.failed += 1;
-		return next;
-	}
-	if (isHit(run.cacheHit)) {
-		next.hits += 1;
-		if (!run.waitedForBuild) {
-			next.hitRuns += 1;
-			next.hitRunMs += durationMs;
-			next.timeSavedMs += credit;
-		}
-		return next;
-	}
-	next.misses += 1;
-	next.coldRuns += 1;
-	next.coldRunMs += durationMs;
-	return next;
-}
-function creditMs(bucket, run, durationMs) {
-	if (run.failed || !isHit(run.cacheHit) || run.waitedForBuild) return 0;
-	if (!bucket || bucket.coldRuns <= 0) return 0;
-	return Math.max(0, Math.round(bucket.coldRunMs / bucket.coldRuns) - durationMs);
-}
-function isHit(cacheHit) {
-	return cacheHit === "local" || cacheHit === "remote";
-}
-function positive(value) {
-	const ms = wholeMs(value);
-	return ms > 0 ? ms : null;
-}
-function wholeMs(value) {
-	const ms = Number(value);
-	return Number.isFinite(ms) && ms > 0 ? Math.round(ms) : 0;
-}
-function count(value) {
-	return wholeMs(value);
-}
-function timestamp(value) {
-	return typeof value === "string" && value !== "" ? value : (/* @__PURE__ */ new Date(0)).toISOString();
-}
-function canonical(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return resolve(path);
-	}
-}
-//#endregion
-export { statsProjectKey as a, recordRunStats as i, readRunEstimates as n, readStats as r, createRunRecorder as t };

package/dist/stim-desktop-CXt8-Z3J.mjs

@@ -1,40 +0,0 @@
-import { t as getExecutor } from "./exec-DK8KaVHK.mjs";
-//#region src/devices/stim-desktop.ts
-const LAUNCH_SERVICES_LOOKUP = `ObjC.import('AppKit'); const url = $.NSWorkspace.sharedWorkspace.URLForApplicationWithBundleIdentifier('dev.stim.desktop'); url.isNil() ? '' : url.path.js`;
-const STIM_DESKTOP_INSTALLED = "Stim Desktop installed";
-/**
-* macOS `open` passes its environment to an app it launches, so Stim Desktop
-* started by a command run under a scoped `STIM_HOME` would serve that home.
-*/
-const STIM_DESKTOP_OPEN_OPTIONS = {
-	timeoutMs: 5e3,
-	killSignal: "SIGKILL",
-	omitEnv: ["STIM_HOME"]
-};
-/** Stim Desktop sets `STIM_DESKTOP_APP` to its bundle path for every command it runs; a non-empty value means Desktop is installed. */
-function stimDesktopInstalled(platform = process.platform, env = process.env) {
-	if (platform !== "darwin") return false;
-	if (env.STIM_DESKTOP_APP) return true;
-	const found = getExecutor().runFileQuiet("osascript", [
-		"-l",
-		"JavaScript",
-		"-e",
-		LAUNCH_SERVICES_LOOKUP
-	], {
-		timeoutMs: 5e3,
-		killSignal: "SIGKILL"
-	});
-	return Boolean(found);
-}
-function settingDefault(setting, desktopInstalled = stimDesktopInstalled) {
-	if (setting.desktopDefault !== void 0 && desktopInstalled()) return {
-		value: setting.desktopDefault,
-		reason: STIM_DESKTOP_INSTALLED
-	};
-	return {
-		value: setting.default,
-		reason: null
-	};
-}
-//#endregion
-export { settingDefault as n, stimDesktopInstalled as r, STIM_DESKTOP_OPEN_OPTIONS as t };