@stim-cli/core 1.8.0 → 1.10.0

package/dist/index.mjs

@@ -1,347 +1,3 @@
-import { S as quotedPath, _ as releaseClaim, r as ClaimRefusedError, x as tryAcquireClaim } from "./ownership-claim-Cn3NHqBS.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";
-import { createHash } from "node:crypto";
-//#region dir-lock.ts
-const DEFAULT_LOCK_WAIT_MS = 12e3;
-const DEFAULT_LOCK_POLL_MS = 25;
-const lockDepths = /* @__PURE__ */ new Map();
-const OWNER_MARKER = /^\.stim-claim-[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/;
-function sleepSync(ms) {
-	Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-/**
-* Whether Windows refused a call on the lock directory because another process is removing it at that
-* moment. NTFS answers ERROR_ACCESS_DENIED, which Node reports as EPERM, until that removal completes,
-* where POSIX answers EEXIST or ENOENT: https://github.com/appandflow/stim/issues/883.
-*/
-function removalInFlight(error) {
-	return process.platform === "win32" && error?.code === "EPERM";
-}
-function createLockDirectory(lockPath) {
-	try {
-		mkdirSync(lockPath);
-		return true;
-	} catch (error) {
-		if (error?.code === "EEXIST" || removalInFlight(error)) return false;
-		throw error;
-	}
-}
-function removeLockDirectory(lockPath, marker) {
-	try {
-		unlinkSync(marker);
-	} catch (error) {
-		if (error?.code === "ENOENT" || removalInFlight(error)) return false;
-		throw error;
-	}
-	try {
-		rmdirSync(lockPath);
-		return true;
-	} catch (error) {
-		if ([
-			"ENOENT",
-			"ENOTEMPTY",
-			"EEXIST"
-		].includes(error?.code ?? "")) return false;
-		if (removalInFlight(error)) return false;
-		throw error;
-	}
-}
-function takeLockDirectory(lockPath, claim) {
-	if (!createLockDirectory(lockPath)) {
-		let entries;
-		try {
-			entries = readdirSync(lockPath);
-		} catch (error) {
-			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
-			throw error;
-		}
-		const name = entries.length === 1 ? entries[0] : void 0;
-		if (!name || !OWNER_MARKER.test(name)) return null;
-		const marker = join(lockPath, name);
-		let entry;
-		try {
-			entry = lstatSync(marker);
-		} catch (error) {
-			if (error?.code === "ENOENT" || removalInFlight(error)) return null;
-			throw error;
-		}
-		if (!entry.isFile() || entry.size !== 0) throw new ClaimRefusedError({
-			root: lockPath,
-			claimPath: lockPath,
-			label: "directory lock",
-			reason: `its compatibility marker ${name} is not an empty file`
-		});
-		if (!removeLockDirectory(lockPath, marker) || !createLockDirectory(lockPath)) return null;
-	}
-	const marker = join(lockPath, `.stim-claim-${claim.claimId}`);
-	writeFileSync(marker, "", { flag: "wx" });
-	return marker;
-}
-function acquireDirLock(lockPath, { waitMs, pollMs, ensureParent }) {
-	ensureParent?.();
-	statSync(dirname(lockPath));
-	const deadline = Date.now() + waitMs;
-	let claim;
-	try {
-		for (;;) {
-			if (!claim) {
-				const attempt = tryAcquireClaim({
-					root: `${lockPath}.claims`,
-					mode: "exclusive",
-					label: "directory lock"
-				});
-				claim = attempt.acquired;
-				if (attempt.pending) releaseClaim(attempt.pending);
-			}
-			if (claim) {
-				const marker = takeLockDirectory(lockPath, claim);
-				if (marker) return {
-					claim,
-					marker
-				};
-			}
-			if (Date.now() >= deadline) {
-				const error = /* @__PURE__ */ new Error(`Timed out waiting for the lock at ${lockPath}. Another Stim process may be holding it; if none is running, remove that directory.`);
-				error.code = "STIM_LOCK_TIMEOUT";
-				error.lockPath = lockPath;
-				throw error;
-			}
-			sleepSync(pollMs);
-		}
-	} catch (error) {
-		releaseClaim(claim);
-		throw error;
-	}
-}
-function withDirLock(lockPath, fn, { waitMs = DEFAULT_LOCK_WAIT_MS, pollMs = DEFAULT_LOCK_POLL_MS, ensureParent } = {}) {
-	const depth = lockDepths.get(lockPath) || 0;
-	if (depth > 0) {
-		lockDepths.set(lockPath, depth + 1);
-		try {
-			return fn();
-		} finally {
-			lockDepths.set(lockPath, (lockDepths.get(lockPath) ?? 1) - 1);
-		}
-	}
-	const { claim, marker } = acquireDirLock(lockPath, {
-		waitMs,
-		pollMs,
-		ensureParent
-	});
-	lockDepths.set(lockPath, 1);
-	try {
-		return fn();
-	} finally {
-		lockDepths.set(lockPath, 0);
-		try {
-			removeLockDirectory(lockPath, marker);
-		} catch {}
-		releaseClaim(claim);
-	}
-}
-//#endregion
-//#region artifact-store.ts
-function artifactIn(dir) {
-	if (!existsSync(dir)) return null;
-	let found;
-	try {
-		found = readdirSync(dir).find((f) => f.endsWith(".app") || f.endsWith(".apk"));
-	} catch {
-		return null;
-	}
-	return found ? join(dir, found) : null;
-}
-function resolveArtifact(dir) {
-	const hit = artifactIn(dir);
-	if (!hit) return null;
-	try {
-		utimesSync(dir, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
-	} catch {}
-	return hit;
-}
-function storeArtifact(dest, buildPath, { runFile, overwrite = false, writeMetadata, onRenameError }) {
-	const existing = artifactIn(dest);
-	if (existing && !overwrite) return existing;
-	const staging = `${dest}.staging-${process.pid}`;
-	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))
-		]);
-	}
-	writeMetadata?.(staging);
-	mkdirSync(dirname(dest), { recursive: true });
-	rmSync(dest, {
-		recursive: true,
-		force: true
-	});
-	try {
-		renameSync(staging, dest);
-	} catch (error) {
-		if (!onRenameError) throw error;
-		onRenameError(staging);
-	}
-	return artifactIn(dest);
-}
-//#endregion
-//#region index.ts
-function configDir() {
-	return process.env.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";
-}
-function workspaceId(projectRoot) {
-	return createHash("sha256").update(path.resolve(projectRoot)).digest("hex").slice(0, 16);
-}
-function workspaceName(projectRoot) {
-	return `${workspaceSlug(projectRoot)}--${workspaceId(projectRoot)}`;
-}
-function workspaceStateDir(projectRoot) {
-	return path.join(configDir(), "workspaces", workspaceName(projectRoot));
-}
-function workspaceLogDir(projectRoot) {
-	return path.join(workspaceStateDir(projectRoot), "logs");
-}
-function cachePathSetting(key) {
-	try {
-		const value = JSON.parse(fs.readFileSync(path.join(configDir(), "config.json"), "utf-8"))?.caches?.[key];
-		return typeof value === "string" && path.isAbsolute(value) ? value : null;
-	} catch {
-		return null;
-	}
-}
-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");
-}
-function metroCacheRoot(name) {
-	const root = process.env.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";
-function tagSharedStore(store, root) {
-	try {
-		Object.defineProperty(store, STORE_ROOT_TAG, {
-			value: root,
-			enumerable: false,
-			configurable: true
-		});
-	} catch {}
-	return store;
-}
-function sharedStoreRoot(store) {
-	if (store === null || typeof store !== "object") return null;
-	const tagged = store[STORE_ROOT_TAG];
-	if (typeof tagged === "string") return tagged;
-	const legacy = store._root;
-	return typeof legacy === "string" ? legacy : null;
-}
-const SIMULATOR_UDID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-const EMULATOR_SERIAL = /^emulator-\d+$/;
-function slug(value) {
-	return String(value).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function buildVariant(platform, options) {
-	const raw = platform === "android" ? options.variant : options.configuration ?? options.buildConfiguration;
-	return (typeof raw === "string" ? slug(raw) : "") || "debug";
-}
-function buildTarget(options) {
-	if (typeof options.isSimulator === "boolean") return options.isSimulator ? "sim" : "device";
-	const device = options.device;
-	if (device === void 0 || device === null || device === false) return "sim";
-	if (typeof device !== "string") return "prompted";
-	const name = device.trim();
-	if (name === "" || name === "generic") return "sim";
-	if (SIMULATOR_UDID.test(name) || EMULATOR_SERIAL.test(name)) return "sim";
-	return `on-${slug(name)}`;
-}
-function buildCacheKey(platform, fingerprintHash, options = {}) {
-	const opts = options && typeof options === "object" ? options : {};
-	const abi = platform === "android" && typeof opts.abi === "string" ? slug(opts.abi) : "";
-	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}` : ""}`;
-}
-const METRO_NAMED_CACHE_LAYOUT = "metro-named-v1";
-function cacheManifestLockPath(file) {
-	return `${file}.lock`;
-}
-function readCacheManifest(file) {
-	try {
-		const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
-		return {
-			version: 1,
-			caches: Array.isArray(parsed?.caches) ? parsed.caches : []
-		};
-	} catch {
-		return {
-			version: 1,
-			caches: []
-		};
-	}
-}
-function updateCacheManifest(file, mutate) {
-	const parent = path.dirname(file);
-	return withDirLock(cacheManifestLockPath(file), () => {
-		const next = {
-			version: 1,
-			caches: mutate(readCacheManifest(file).caches)
-		};
-		const temporary = path.join(parent, `.${path.basename(file)}.${process.pid}.tmp`);
-		try {
-			fs.writeFileSync(temporary, JSON.stringify(next, null, 2));
-			fs.renameSync(temporary, file);
-		} catch (error) {
-			fs.rmSync(temporary, { force: true });
-			throw error;
-		}
-		return next;
-	}, { ensureParent: () => fs.mkdirSync(parent, { recursive: true }) });
-}
-function registerCache({ dir, name, prune, note, entriesDepth, layout, replaces = [] }) {
-	try {
-		updateCacheManifest(path.join(configDir(), "caches.json"), (caches) => {
-			const others = caches.filter((cache) => cache.dir !== dir && !replaces.some((match) => matchesCache(cache, match)));
-			const record = {
-				dir,
-				name,
-				prune,
-				note,
-				registeredBy: process.cwd()
-			};
-			if (entriesDepth) record.entriesDepth = entriesDepth;
-			if (layout) record.layout = layout;
-			others.push(record);
-			return others;
-		});
-	} catch {}
-}
-function matchesCache(cache, match) {
-	if (cache.dir !== match.dir) return false;
-	if (match.name !== void 0 && cache.name !== match.name) return false;
-	if (match.prune !== void 0 && cache.prune !== match.prune) return false;
-	if (match.entriesDepth !== void 0 && cache.entriesDepth !== match.entriesDepth) return false;
-	if (match.layout === null) return !Object.hasOwn(cache, "layout");
-	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 };
+import { S as quotedPath } from "./ownership-claim-O31Y5iIb.mjs";
+import { C as artifactIn, E as withDirLock, S as workspaceStateDir, T as storeArtifact, _ as updateCacheManifest, a as buildCacheRoot, b as workspaceName, c as cachePathSetting, d as readCacheManifest, f as registerCache, g as tagSharedStore, h as sharedStoreRoot, i as buildCacheKey, l as configDir, m as rotatedLogPath, n as METRO_NAMED_CACHE_LAYOUT, o as cacheManifestLockPath, p as rotateLog, r as STORE_ROOT_TAG, s as cacheNameSegment, t as LOG_ROTATE_BYTES, u as metroCacheRoot, v as workspaceId, w as resolveArtifact, x as workspaceSlug, y as workspaceLogDir } from "./core-CJWLJIr6.mjs";
+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/dist/process-identity.d.mts

@@ -15,6 +15,16 @@ declare function captureProcessIdentity(pid: number): CapturedIdentity;
 declare function captureProcessToken(pid: number): string | null;
 type ProcessIdentityStatus = "same" | "different" | "gone" | "unknown";
 declare function inspectProcessIdentity(record: ProcessRecord | null | undefined): ProcessIdentityStatus;
+type ProcessStart = {
+  status: "running";
+  startedAtMs: number;
+} | {
+  status: "gone";
+} | {
+  status: "unknown";
+};
+/** Start time of a live process, read from the same OS identity that `captureProcessIdentity` records. */
+declare function inspectProcessStart(pid: number): ProcessStart;
 declare function waitForProcessExit(record: ProcessRecord, timeoutMs: number): Promise<boolean>;
 //#endregion
-export { CapturedIdentity, ProcessIdentityStatus, ProcessRecord, captureProcessIdentity, captureProcessToken, inspectProcessIdentity, sameProcessRecord, waitForProcessExit };
+export { CapturedIdentity, ProcessIdentityStatus, ProcessRecord, ProcessStart, captureProcessIdentity, captureProcessToken, inspectProcessIdentity, inspectProcessStart, sameProcessRecord, waitForProcessExit };

package/dist/process-identity.mjs

@@ -26,6 +26,19 @@ function inspectProcessIdentity(record) {
 	const result = check(record.processToken);
 	return result.ok ? result.value : "unknown";
 }
+/** Start time of a live process, read from the same OS identity that `captureProcessIdentity` records. */
+function inspectProcessStart(pid) {
+	const captured = capture(pid);
+	if (!captured.ok) return captured.error.code === "NOT_FOUND" ? { status: "gone" } : { status: "unknown" };
+	const decoded = decode(captured.value);
+	if (!decoded.ok || decoded.value.platform !== "darwin") return { status: "unknown" };
+	const match = /^(\d+):(\d+)$/.exec(decoded.value.startTime);
+	if (!match) return { status: "unknown" };
+	return {
+		status: "running",
+		startedAtMs: Number(match[1]) * 1e3 + Math.floor(Number(match[2]) / 1e3)
+	};
+}
 async function waitForProcessExit(record, timeoutMs) {
 	const deadline = Date.now() + timeoutMs;
 	while (Date.now() <= deadline) {
@@ -37,4 +50,4 @@ async function waitForProcessExit(record, timeoutMs) {
 	return false;
 }
 //#endregion
-export { captureProcessIdentity, captureProcessToken, inspectProcessIdentity, sameProcessRecord, waitForProcessExit };
+export { captureProcessIdentity, captureProcessToken, inspectProcessIdentity, inspectProcessStart, sameProcessRecord, waitForProcessExit };