@stim-cli/core 1.8.0-rc.1 → 1.9.0

package/dist/index.d.mts

@@ -30,6 +30,10 @@ declare function workspaceId(projectRoot: string): string;
 declare function workspaceName(projectRoot: string): string;
 declare function workspaceStateDir(projectRoot: string): string;
 declare function workspaceLogDir(projectRoot: string): string;
+declare const LOG_ROTATE_BYTES: number;
+declare function rotatedLogPath(file: string): string;
+/** Moves `file` over its previous generation once it reaches `maxBytes`; readers read both generations. */
+declare function rotateLog(file: string, maxBytes: number): void;
 declare function cachePathSetting(key: "buildCache" | "metroCache"): string | null;
 declare function cacheNameSegment(name: string | null | undefined): string;
 declare function buildCacheRoot(): string;
@@ -42,6 +46,7 @@ interface BuildRunOptions {
   compiler?: string;
   variant?: string;
   abi?: string;
+  allArch?: boolean;
   configuration?: string;
   scheme?: string;
   buildConfiguration?: string;
@@ -75,4 +80,4 @@ declare function readCacheManifest(file: string): CacheManifest;
 declare function updateCacheManifest(file: string, mutate: (caches: Array<Record<string, unknown>>) => Array<Record<string, unknown>>): CacheManifest;
 declare function registerCache({ dir, name, prune, note, entriesDepth, layout, replaces }: RegisterOptions): void;
 //#endregion
-export { BuildRunOptions, CacheManifest, CacheRegistrationMatch, type DirLockOptions, METRO_NAMED_CACHE_LAYOUT, RegisterOptions, STORE_ROOT_TAG, type StoreArtifactOptions, artifactIn, buildCacheKey, buildCacheRoot, cacheManifestLockPath, cacheNameSegment, cachePathSetting, configDir, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };
+export { BuildRunOptions, CacheManifest, CacheRegistrationMatch, type DirLockOptions, LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, RegisterOptions, STORE_ROOT_TAG, type StoreArtifactOptions, artifactIn, buildCacheKey, buildCacheRoot, cacheManifestLockPath, cacheNameSegment, cachePathSetting, configDir, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-Cn3NHqBS.mjs";
+import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-O31Y5iIb.mjs";
 import fs, { existsSync, lstatSync, mkdirSync, readdirSync, renameSync, rmSync, rmdirSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path, { basename, dirname, join } from "node:path";
@@ -165,43 +165,94 @@ function storeArtifact(dest, buildPath, { runFile, overwrite = false, writeMetad
 	const existing = artifactIn(dest);
 	if (existing && !overwrite) return existing;
 	const staging = `${dest}.staging-${process.pid}`;
+	const replaced = `${dest}.replaced-${process.pid}`;
+	const target = join(staging, basename(buildPath));
 	rmSync(staging, {
 		recursive: true,
 		force: true
 	});
 	mkdirSync(staging, { recursive: true });
 	try {
-		runFile("cp", [
-			"-c",
-			"-R",
-			buildPath,
-			join(staging, basename(buildPath))
-		]);
-	} catch {
-		runFile("cp", [
-			"-R",
-			buildPath,
-			join(staging, basename(buildPath))
-		]);
+		try {
+			runFile("cp", [
+				"-c",
+				"-R",
+				buildPath,
+				target
+			]);
+		} catch {
+			rmSync(target, {
+				recursive: true,
+				force: true
+			});
+			runFile("cp", [
+				"-R",
+				buildPath,
+				target
+			]);
+		}
+		writeMetadata?.(staging);
+		const published = artifactIn(dest);
+		if (published && !overwrite) {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+			return published;
+		}
+		mkdirSync(dirname(dest), { recursive: true });
+		rmSync(replaced, {
+			recursive: true,
+			force: true
+		});
+		if (existsSync(dest)) renameSync(dest, replaced);
+	} catch (error) {
+		rmSync(staging, {
+			recursive: true,
+			force: true
+		});
+		throw error;
 	}
-	writeMetadata?.(staging);
-	mkdirSync(dirname(dest), { recursive: true });
-	rmSync(dest, {
-		recursive: true,
-		force: true
-	});
 	try {
 		renameSync(staging, dest);
 	} catch (error) {
-		if (!onRenameError) throw error;
+		try {
+			renameSync(replaced, dest);
+		} catch {}
+		if (!onRenameError) {
+			rmSync(staging, {
+				recursive: true,
+				force: true
+			});
+			rmSync(replaced, {
+				recursive: true,
+				force: true
+			});
+			throw error;
+		}
 		onRenameError(staging);
 	}
+	rmSync(replaced, {
+		recursive: true,
+		force: true
+	});
 	return artifactIn(dest);
 }
 //#endregion
 //#region index.ts
+const warnedRelative = /* @__PURE__ */ new Set();
+function absoluteEnvPath(name) {
+	const value = process.env[name];
+	if (!value) return null;
+	if (path.isAbsolute(value)) return value;
+	if (!warnedRelative.has(name)) {
+		warnedRelative.add(name);
+		process.emitWarning(`${name}=${value} is not an absolute path and is ignored.`, { code: "STIM_RELATIVE_PATH" });
+	}
+	return null;
+}
 function configDir() {
-	return process.env.STIM_HOME || path.join(os.homedir(), ".stim");
+	return absoluteEnvPath("STIM_HOME") || path.join(os.homedir(), ".stim");
 }
 function workspaceSlug(projectRoot) {
 	return path.basename(path.resolve(projectRoot)).normalize("NFKD").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, 48) || "workspace";
@@ -218,6 +269,27 @@ function workspaceStateDir(projectRoot) {
 function workspaceLogDir(projectRoot) {
 	return path.join(workspaceStateDir(projectRoot), "logs");
 }
+const LOG_ROTATE_BYTES = 8388608;
+function rotatedLogPath(file) {
+	return `${file}.1`;
+}
+/** Moves `file` over its previous generation once it reaches `maxBytes`; readers read both generations. */
+function rotateLog(file, maxBytes) {
+	if (logSize(file) < maxBytes) return;
+	withDirLock(`${file}.lock`, () => {
+		if (logSize(file) >= maxBytes) fs.renameSync(file, rotatedLogPath(file));
+	}, {
+		waitMs: 100,
+		pollMs: 10
+	});
+}
+function logSize(file) {
+	try {
+		return fs.statSync(file).size;
+	} catch {
+		return 0;
+	}
+}
 function cachePathSetting(key) {
 	try {
 		const value = JSON.parse(fs.readFileSync(path.join(configDir(), "config.json"), "utf-8"))?.caches?.[key];
@@ -230,10 +302,10 @@ function cacheNameSegment(name) {
 	return String(name).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^\.+/, "") || "app";
 }
 function buildCacheRoot() {
-	return process.env.STIM_BUILD_CACHE || cachePathSetting("buildCache") || path.join(configDir(), "build-cache");
+	return absoluteEnvPath("STIM_BUILD_CACHE") || cachePathSetting("buildCache") || path.join(configDir(), "build-cache");
 }
 function metroCacheRoot(name) {
-	const root = process.env.STIM_METRO_CACHE || cachePathSetting("metroCache") || path.join(configDir(), "metro-cache");
+	const root = absoluteEnvPath("STIM_METRO_CACHE") || cachePathSetting("metroCache") || path.join(configDir(), "metro-cache");
 	return name === void 0 || name === null || name === "" ? root : path.join(root, cacheNameSegment(name));
 }
 const STORE_ROOT_TAG = "stimStoreRoot";
@@ -276,10 +348,11 @@ function buildTarget(options) {
 function buildCacheKey(platform, fingerprintHash, options = {}) {
 	const opts = options && typeof options === "object" ? options : {};
 	const abi = platform === "android" && typeof opts.abi === "string" ? slug(opts.abi) : "";
+	const allArch = platform === "android" && opts.allArch === true ? "-all-arch" : "";
 	const compiler = typeof opts.compiler === "string" ? slug(opts.compiler) : "";
 	const profile = typeof opts.buildProfile === "string" ? slug(opts.buildProfile) : "";
 	const scheme = platform === "ios" && typeof opts.scheme === "string" && opts.scheme ? createHash("sha256").update(opts.scheme).digest("hex") : "";
-	return `${fingerprintHash}-${buildVariant(platform, opts)}-${buildTarget(opts)}${abi ? `-${abi}` : ""}${compiler ? `-${compiler}` : ""}${profile ? `-${profile}` : ""}${scheme ? `-scheme-${scheme}` : ""}`;
+	return `${fingerprintHash}-${buildVariant(platform, opts)}-${buildTarget(opts)}${abi ? `-${abi}` : ""}${allArch}${compiler ? `-${compiler}` : ""}${profile ? `-${profile}` : ""}${scheme ? `-scheme-${scheme}` : ""}`;
 }
 const METRO_NAMED_CACHE_LAYOUT = "metro-named-v1";
 function cacheManifestLockPath(file) {
@@ -318,6 +391,7 @@ function updateCacheManifest(file, mutate) {
 	}, { ensureParent: () => fs.mkdirSync(parent, { recursive: true }) });
 }
 function registerCache({ dir, name, prune, note, entriesDepth, layout, replaces = [] }) {
+	if (!path.isAbsolute(dir)) return;
 	try {
 		updateCacheManifest(path.join(configDir(), "caches.json"), (caches) => {
 			const others = caches.filter((cache) => cache.dir !== dir && !replaces.some((match) => matchesCache(cache, match)));
@@ -344,4 +418,4 @@ function matchesCache(cache, match) {
 	return match.layout === void 0 || cache.layout === match.layout;
 }
 //#endregion
-export { METRO_NAMED_CACHE_LAYOUT, STORE_ROOT_TAG, artifactIn, buildCacheKey, buildCacheRoot, cacheManifestLockPath, cacheNameSegment, cachePathSetting, configDir, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };
+export { LOG_ROTATE_BYTES, METRO_NAMED_CACHE_LAYOUT, STORE_ROOT_TAG, artifactIn, buildCacheKey, buildCacheRoot, cacheManifestLockPath, cacheNameSegment, cachePathSetting, configDir, metroCacheRoot, quotedPath, readCacheManifest, registerCache, resolveArtifact, rotateLog, rotatedLogPath, sharedStoreRoot, storeArtifact, tagSharedStore, updateCacheManifest, withDirLock, workspaceId, workspaceLogDir, workspaceName, workspaceSlug, workspaceStateDir };

package/dist/{ownership-claim-Cn3NHqBS.mjs → ownership-claim-O31Y5iIb.mjs}

@@ -18,7 +18,7 @@ const CLAIM_SUFFIX = ".claim";
 const CHILD_SUFFIX = ".child";
 const STAGING_PREFIX = ".staging-";
 const PUBLISH_ATTEMPTS = 64;
-const WIN32_SETTLE_MS = 250;
+const WIN32_SETTLE_MS = 2e3;
 const WIN32_SETTLE_STEP_MS = 5;
 const debug = debuglog("stim:claim");
 var ClaimRefusedError = class extends Error {
@@ -99,61 +99,71 @@ function sleepSync(ms) {
 * Run a read, listing or removal and resolve the one answer Windows leaves ambiguous. NTFS answers
 * ERROR_ACCESS_DENIED, which Node reports as EPERM, for a name whose removal by another process is still
 * in flight, and for every name below it, where POSIX answers ENOENT; measured to settle within 134 ms
-* with 12 processes on 4 cores (https://github.com/appandflow/stim/issues/883). The call is reissued in
-* small steps for at most WIN32_SETTLE_MS: a result or ENOENT is the settled answer, and an EPERM that
-* outlasts the window is a real denial, thrown exactly as a POSIX EACCES is. This bounds the resolution
-* of an ambiguous OS answer; it never waits on a holder.
+* with 12 processes on 4 cores (https://github.com/appandflow/stim/issues/883), and within 986 ms on an
+* oversubscribed hosted windows-latest runner (https://github.com/appandflow/stim/issues/943). The call
+* is reissued in small steps until a call issued WIN32_SETTLE_MS after the first EPERM still answers
+* EPERM, so a call that was itself descheduled past the window never ends it: a result or ENOENT is the
+* settled answer, and an EPERM that outlasts the window is a real denial, thrown exactly as a POSIX
+* EACCES is. This bounds the resolution of an ambiguous OS answer; it never waits on a holder.
 */
 function settledAnswer(path, call) {
 	if (process.platform !== "win32") return call();
-	const started = Date.now();
+	let denied;
 	for (;;) {
+		const asked = Date.now();
 		try {
 			const result = call();
-			if (Date.now() > started) debug("%s settled after %d ms", path, Date.now() - started);
+			if (denied !== void 0) debug("%s settled after %d ms", path, Date.now() - denied);
 			return result;
 		} catch (err) {
-			const code = err?.code;
-			if (code !== "EPERM" || Date.now() - started >= WIN32_SETTLE_MS) {
-				if (code === "EPERM") debug("%s still answers EPERM after %d ms", path, Date.now() - started);
+			if (err?.code !== "EPERM") throw err;
+			denied ??= Date.now();
+			if (asked - denied >= WIN32_SETTLE_MS) {
+				debug("%s still answers EPERM after %d ms", path, Date.now() - denied);
 				throw err;
 			}
 		}
 		sleepSync(WIN32_SETTLE_STEP_MS);
 	}
 }
-function readChild(claimPath) {
-	let text;
+var Unreadable = class {
+	reason;
+	constructor(reason) {
+		this.reason = reason;
+	}
+};
+const NOT_JSON = new Unreadable("its record is missing, truncated or not valid JSON");
+function readRecord(path, what) {
 	try {
-		text = settledAnswer(childPath(claimPath), () => readFileSync(childPath(claimPath), "utf-8"));
+		return settledAnswer(path, () => readFileSync(path, "utf-8"));
 	} catch (err) {
-		if (err?.code === "ENOENT") return null;
-		return "unreadable";
+		const code = err?.code;
+		if (code === "ENOENT") return null;
+		return new Unreadable(`its ${what} could not be read (${code || err?.message})`);
 	}
+}
+function readChild(claimPath) {
+	const text = readRecord(childPath(claimPath), "child record");
+	if (text === null || text instanceof Unreadable) return text;
 	try {
 		return { record: asOwner(JSON.parse(text)?.record) };
 	} catch {
-		return "unreadable";
+		return NOT_JSON;
 	}
 }
 function readClaim(path, mode) {
-	let text;
-	try {
-		text = settledAnswer(path, () => readFileSync(path, "utf-8"));
-	} catch (err) {
-		if (err?.code === "ENOENT") return null;
-		return "unreadable";
-	}
+	const text = readRecord(path, "record");
+	if (text === null || text instanceof Unreadable) return text;
 	let parsed;
 	try {
 		parsed = JSON.parse(text);
 	} catch {
-		return "unreadable";
+		return NOT_JSON;
 	}
 	const owner = asOwner(parsed?.owner);
-	if (!owner || typeof parsed.claimId !== "string" || !parsed.claimId) return "unreadable";
+	if (!owner || typeof parsed.claimId !== "string" || !parsed.claimId) return NOT_JSON;
 	const child = readChild(path);
-	if (child === "unreadable") return "unreadable";
+	if (child instanceof Unreadable) return child;
 	return {
 		path,
 		claimId: parsed.claimId,
@@ -183,7 +193,7 @@ function processGroupAlive(pid) {
 function childLiveness(claimPath) {
 	const child = readChild(claimPath);
 	if (child === null) return "none";
-	if (child === "unreadable" || !child.record) return "unknown";
+	if (child instanceof Unreadable || !child.record) return "unknown";
 	const status = inspectProcessIdentity(child.record);
 	if (status === "same") return "live";
 	if (status === "gone") return processGroupAlive(child.record.pid) ? "live" : "dead";
@@ -252,10 +262,10 @@ function survey(dir, mode, into) {
 		const path = join(dir, name);
 		const holder = readClaim(path, mode);
 		if (holder === null) continue;
-		if (holder === "unreadable") {
+		if (holder instanceof Unreadable) {
 			into.unresolved.push({
 				path,
-				reason: "its record is missing, truncated or not valid JSON"
+				reason: holder.reason
 			});
 			continue;
 		}
@@ -296,7 +306,7 @@ function removeOrRefuse(path, root, claimPath, label) {
 function reap(holder, root, label) {
 	const again = readClaim(holder.path, holder.mode);
 	if (again === null) return true;
-	if (again === "unreadable" || again.claimId !== holder.claimId) return false;
+	if (again instanceof Unreadable || again.claimId !== holder.claimId) return false;
 	removeOrRefuse(childPath(holder.path), root, holder.path, label);
 	removeOrRefuse(holder.path, root, holder.path, label);
 	return true;
@@ -606,7 +616,7 @@ function releaseClaim(handle) {
 	if (!handle) return false;
 	const current = readClaim(handle.path, handle.mode);
 	if (current === null) return true;
-	if (current === "unreadable" || current.claimId !== handle.claimId) return false;
+	if (current instanceof Unreadable || current.claimId !== handle.claimId) return false;
 	try {
 		rmSync(childPath(handle.path), { force: true });
 		rmSync(handle.path, { force: true });

package/dist/ownership-claim.mjs

@@ -1,2 +1,2 @@
-import { _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as tryAcquireClaim, y as settleClaim } from "./ownership-claim-Cn3NHqBS.mjs";
+import { _ as releaseClaim, a as claimFailure, b as sharedClaimDir, c as clearClaimChild, d as inspectClaimSet, f as isClaimRefusal, g as readClaimSet, h as processGroupAlive, i as ClaimUnavailableError, l as clearFreeClaimSet, m as markClaimChildPending, n as CLAIM_UNAVAILABLE, o as claimLiveness, p as isClaimUnavailable, r as ClaimRefusedError, s as claimRemoveCommand, t as CLAIM_REFUSED, u as exclusiveClaimDir, v as setClaimChild, x as tryAcquireClaim, y as settleClaim } from "./ownership-claim-O31Y5iIb.mjs";
 export { CLAIM_REFUSED, CLAIM_UNAVAILABLE, ClaimRefusedError, ClaimUnavailableError, claimFailure, claimLiveness, claimRemoveCommand, clearClaimChild, clearFreeClaimSet, exclusiveClaimDir, inspectClaimSet, isClaimRefusal, isClaimUnavailable, markClaimChildPending, processGroupAlive, readClaimSet, releaseClaim, setClaimChild, settleClaim, sharedClaimDir, tryAcquireClaim };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stim-cli/core",
-  "version": "1.8.0-rc.1",
+  "version": "1.9.0",
   "description": "Shared internal cache and runtime primitives for Stim packages.",
   "license": "MIT",
   "repository": {