stim 1.0.0 → 1.2.0

package/dist/logs-query-oqn47Ffx.mjs

@@ -0,0 +1,273 @@
+import { a as parseNdjsonLine, i as levelRank, o as parseNdjsonText } from "./ndjson-DcAtEx_K.mjs";
+import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { StringDecoder } from "string_decoder";
+//#region src/logs-query.ts
+const SINCE_UNITS = {
+	s: 1e3,
+	m: 6e4,
+	h: 36e5
+};
+const SINCE_FORMS = "30s, 5m, 2h";
+function parseSince(text) {
+	if (typeof text !== "string") return { error: `Invalid --since value ${JSON.stringify(text)}. Use a count and a unit, e.g. ${SINCE_FORMS}.` };
+	const m = /^(\d+)\s*([smh])$/i.exec(text.trim());
+	if (!m) return { error: `Invalid --since value "${text}". Use a count and a unit, e.g. ${SINCE_FORMS}.` };
+	const unit = (m[2] ?? "").toLowerCase();
+	return { ms: parseInt(m[1] ?? "", 10) * SINCE_UNITS[unit] };
+}
+function compileGrep(pattern) {
+	if (pattern instanceof RegExp) return { re: pattern };
+	try {
+		return { re: new RegExp(String(pattern)) };
+	} catch (err) {
+		return { error: `Invalid --grep pattern "${pattern}": ${err.message}` };
+	}
+}
+const ERROR_SOURCES = [
+	"metro",
+	"client",
+	"build"
+];
+function markerWindow(records) {
+	let launchTs = null;
+	let bundleTs = null;
+	for (const r of records) {
+		if (r?.marker !== true) continue;
+		const ts = tsOf(r);
+		if (ts === null) continue;
+		if (r.src === "metro") {
+			if (bundleTs === null || ts > bundleTs) bundleTs = ts;
+		} else if (launchTs === null || ts > launchTs) launchTs = ts;
+	}
+	return {
+		launchTs,
+		bundleTs
+	};
+}
+function recordMatches(record, criteria = {}) {
+	if (!record) return false;
+	const { sources, minLevel, grep, sinceTs, errorsOnly, markerTs, bundleMarkerTs } = criteria;
+	if (sources && sources.length > 0 && !sources.includes(record.src) && !(criteria.includeNativeCrashes && record.src === "device" && record.event === "native_crash")) return false;
+	if (minLevel && levelRank(record.level) < levelRank(minLevel)) return false;
+	if (errorsOnly) {
+		if (record.level !== "error" && record.level !== "fatal") return false;
+		if (typeof markerTs === "number") {
+			const ts = tsOf(record);
+			if (ts === null || ts <= markerTs) return false;
+		}
+		if (typeof bundleMarkerTs === "number" && record.src === "metro") {
+			const ts = tsOf(record);
+			if (ts === null || ts < bundleMarkerTs) return false;
+		}
+	}
+	if (typeof sinceTs === "number") {
+		const ts = tsOf(record);
+		if (ts === null || ts < sinceTs) return false;
+	}
+	if (grep) {
+		const re = grep instanceof RegExp ? grep : compileGrep(grep).re;
+		if (!re || String(record.msg ?? "").search(re) === -1) return false;
+	}
+	return true;
+}
+function buildCriteria({ sources, minLevel, since, grep, errorsOnly, markerTs, bundleMarkerTs, now } = {}) {
+	const criteria = {
+		errorsOnly: Boolean(errorsOnly),
+		includeNativeCrashes: Boolean(errorsOnly && !sources?.length)
+	};
+	if (sources && sources.length > 0) criteria.sources = sources;
+	else if (criteria.errorsOnly) criteria.sources = ERROR_SOURCES;
+	if (minLevel) criteria.minLevel = minLevel;
+	if (typeof markerTs === "number") criteria.markerTs = markerTs;
+	if (typeof bundleMarkerTs === "number") criteria.bundleMarkerTs = bundleMarkerTs;
+	if (since !== void 0 && since !== null && since !== "") {
+		const parsed = parseSince(since);
+		if (parsed.error) throw new Error(parsed.error);
+		criteria.sinceTs = (typeof now === "number" ? now : Date.now()) - parsed.ms;
+	}
+	if (grep !== void 0 && grep !== null && grep !== "") {
+		const compiled = compileGrep(grep);
+		if (compiled.error) throw new Error(compiled.error);
+		criteria.grep = compiled.re;
+	}
+	return criteria;
+}
+function logFiles(dir) {
+	let entries;
+	try {
+		entries = readdirSync(dir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+	return entries.filter((e) => e.isFile() && e.name.endsWith(".ndjson")).map((e) => e.name).toSorted();
+}
+function fileSizes(dir) {
+	const sizes = {};
+	for (const name of logFiles(dir)) try {
+		sizes[name] = statSync(join(dir, name)).size;
+	} catch {}
+	return sizes;
+}
+function readLogRecords(dir) {
+	const all = [];
+	for (const name of logFiles(dir)) {
+		let text;
+		try {
+			text = readFileSync(join(dir, name), "utf-8");
+		} catch {
+			continue;
+		}
+		for (const record of parseNdjsonText(text)) all.push(record);
+	}
+	return sortByTs(all);
+}
+function isExpoErrorContext(record, event) {
+	if (record.src !== "metro" || record.raw !== true || record.event !== event || typeof record.msg !== "string") return false;
+	return /^Code: \S/.test(record.msg) || /^\s*>?\s*\d+\s*\|/.test(record.msg) || /^\s*\|\s*\^/.test(record.msg) || /^Call Stack$/.test(record.msg) || /^\s+.+\([^()]+:\d+:\d+\)\s*$/.test(record.msg) || /^\s+at\s+\S+:\d+:\d+\s*$/.test(record.msg);
+}
+function attachExpoErrorContext(all, matched) {
+	return matched.map((record) => {
+		if (record.src !== "metro" || record.raw !== true || record.level !== "error" && record.level !== "fatal" || typeof record.msg !== "string") return record;
+		const index = all.findIndex((entry) => entry.ts === record.ts && entry.src === record.src && entry.msg === record.msg && entry.event === record.event);
+		if (index === -1) return record;
+		const context = [];
+		for (let i = index + 1; i < all.length; i += 1) {
+			const next = all[i];
+			if (next.src !== "metro") continue;
+			if (!isExpoErrorContext(next, record.event)) break;
+			context.push(next.msg);
+		}
+		return context.length > 0 ? {
+			...record,
+			msg: [record.msg, ...context].join("\n")
+		} : record;
+	});
+}
+function includeBareErrorContext(all, matched, launchTs, sinceTs) {
+	if (!matched.some((record) => record.src === "client" && (record.level === "error" || record.level === "fatal"))) return matched;
+	const renderedContext = [];
+	for (const record of all) {
+		if (record.src !== "client" || record.event !== "client_symbolication") continue;
+		const ts = tsOf(record);
+		if (launchTs !== null && (ts === null || ts <= launchTs)) continue;
+		if (sinceTs !== void 0 && (ts === null || ts < sinceTs)) continue;
+		renderedContext.push({
+			...record,
+			msg: `Metro symbolication context (not correlated to a specific client error)\n${String(record.msg ?? "")}`,
+			errorContext: true
+		});
+	}
+	return sortByTs([...matched, ...renderedContext]);
+}
+function queryLogs({ dir, sources, minLevel, since, grep, tail, errorsOnly, errorContext, now } = {}) {
+	const all = readLogRecords(dir);
+	if (all.length === 0) return [];
+	const { launchTs, bundleTs } = errorsOnly ? markerWindow(all) : {
+		launchTs: null,
+		bundleTs: null
+	};
+	const criteria = buildCriteria({
+		sources,
+		minLevel,
+		since,
+		grep,
+		errorsOnly,
+		now,
+		markerTs: launchTs === null ? void 0 : launchTs,
+		bundleMarkerTs: bundleTs === null ? void 0 : bundleTs
+	});
+	let matched = all.filter((r) => recordMatches(r, criteria));
+	if (typeof tail === "number" && tail >= 0 && matched.length > tail) matched = matched.slice(matched.length - tail);
+	return errorContext ? includeBareErrorContext(all, attachExpoErrorContext(all, matched), launchTs, criteria.sinceTs) : matched;
+}
+function tailRead(prev, size) {
+	const state = prev && typeof prev.offset === "number" ? prev : {
+		offset: 0,
+		partial: ""
+	};
+	if (size < state.offset) return {
+		start: 0,
+		prev: {
+			offset: 0,
+			partial: ""
+		}
+	};
+	return {
+		start: state.offset,
+		prev: state
+	};
+}
+function advanceTail(prev, chunk, size) {
+	const lines = ((prev && typeof prev.partial === "string" ? prev.partial : "") + (chunk || "")).split("\n");
+	const partial = lines.pop();
+	const records = [];
+	for (const line of lines) {
+		const record = parseNdjsonLine(line);
+		if (record) records.push(record);
+	}
+	return {
+		state: {
+			offset: size,
+			partial
+		},
+		records
+	};
+}
+function followLogs({ dir, onRecord, criteria = {}, intervalMs = 500, offsets = null }) {
+	const state = /* @__PURE__ */ new Map();
+	const decoders = /* @__PURE__ */ new Map();
+	for (const [name, size] of Object.entries(offsets || fileSizes(dir))) {
+		state.set(name, {
+			offset: size,
+			partial: ""
+		});
+		decoders.set(name, new StringDecoder("utf8"));
+	}
+	function pollFile(name) {
+		const path = join(dir, name);
+		const size = statSync(path).size;
+		const entry = state.get(name);
+		const { start, prev } = tailRead(entry, size);
+		if (prev !== entry) decoders.set(name, new StringDecoder("utf8"));
+		if (!decoders.has(name)) decoders.set(name, new StringDecoder("utf8"));
+		let chunk = "";
+		if (size > start) {
+			const fd = openSync(path, "r");
+			try {
+				const buf = Buffer.allocUnsafe(size - start);
+				const read = readSync(fd, buf, 0, size - start, start);
+				chunk = decoders.get(name).write(buf.subarray(0, read));
+			} finally {
+				closeSync(fd);
+			}
+		}
+		const next = advanceTail(prev, chunk, size);
+		state.set(name, next.state);
+		for (const record of next.records) if (recordMatches(record, criteria)) onRecord(record);
+	}
+	function poll() {
+		for (const name of logFiles(dir)) try {
+			pollFile(name);
+		} catch {}
+	}
+	const timer = setInterval(poll, intervalMs);
+	return function stop() {
+		clearInterval(timer);
+	};
+}
+function tsOf(record) {
+	return typeof record?.ts === "number" && Number.isFinite(record.ts) ? record.ts : null;
+}
+function sortByTs(records) {
+	return records.toSorted((a, b) => {
+		const ta = tsOf(a);
+		const tb = tsOf(b);
+		if (ta === null && tb === null) return 0;
+		if (ta === null) return 1;
+		if (tb === null) return -1;
+		return ta - tb;
+	});
+}
+//#endregion
+export { followLogs as a, readLogRecords as c, fileSizes as i, buildCriteria as n, parseSince as o, compileGrep as r, queryLogs as s, attachExpoErrorContext as t };

package/dist/metro-COslRK_F.mjs

@@ -0,0 +1,184 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { E as inspectProcessIdentity, M as isOnMountedVolume, N as listMountedVolumes, g as loadConfig, n as allMetroPorts, r as claimMetroPort, v as removeProject } from "./config-CMtIaTk9.mjs";
+import { p as readWorkspaceState } from "./state-CZ-ER-8d.mjs";
+import { existsSync, readlinkSync, realpathSync } from "fs";
+import { sep } from "path";
+import { request } from "http";
+import { connect } from "net";
+//#region src/ports.ts
+function isMetroRunning(port) {
+	return new Promise((resolve) => {
+		const req = request({
+			hostname: "localhost",
+			port,
+			path: "/status",
+			timeout: 2e3
+		}, (res) => {
+			let data = "";
+			res.on("data", (chunk) => {
+				data += chunk;
+			});
+			res.on("end", () => resolve(data.includes("packager-status:running")));
+		});
+		req.on("error", () => resolve(false));
+		req.on("timeout", () => {
+			req.destroy();
+			resolve(false);
+		});
+		req.end();
+	});
+}
+function isPortFree(port, { timeoutMs = 400 } = {}) {
+	return new Promise((resolve) => {
+		const sock = connect({
+			port,
+			host: "127.0.0.1"
+		});
+		const done = (free) => {
+			sock.removeAllListeners();
+			sock.destroy();
+			resolve(free);
+		};
+		sock.setTimeout(timeoutMs);
+		sock.once("connect", () => done(false));
+		sock.once("error", () => done(true));
+		sock.once("timeout", () => done(false));
+	});
+}
+const FIRST_PORT = 8082;
+async function computeNextPort(isFree = isPortFree) {
+	const taken = new Set(allMetroPorts());
+	for (let port = FIRST_PORT; port < 8282; port++) {
+		if (taken.has(port)) continue;
+		if (await isFree(port)) return port;
+	}
+	throw new Error(`Found no free Metro port between ${FIRST_PORT} and 8281. Free one up, or stop a stale bundler (\`stim status\`, \`stim stop <port>\`).`);
+}
+async function findReclaimablePort(excludeProjectPath, probe = isMetroRunning, { isMounted = isOnMountedVolume, mountedVolumes } = {}) {
+	const cfg = loadConfig();
+	if (!cfg?.projects) return null;
+	const mounted = mountedVolumes || listMountedVolumes();
+	const candidates = [];
+	for (const [path, proj] of Object.entries(cfg.projects)) {
+		if (path === excludeProjectPath) continue;
+		if (existsSync(path)) continue;
+		if (!isMounted(path, mounted)) continue;
+		if (typeof proj.metroPort === "number") candidates.push({
+			port: proj.metroPort,
+			ownerPath: path
+		});
+	}
+	for (const c of candidates) if (!await probe(c.port)) return c;
+	return null;
+}
+async function allocatePort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	const reclaim = await findReclaimablePort(projectPath, probe);
+	if (reclaim && await isFree(reclaim.port)) {
+		removeProject(reclaim.ownerPath);
+		return reclaim.port;
+	}
+	return computeNextPort(isFree);
+}
+const RESERVE_ATTEMPTS = 5;
+async function reserveMetroPort(projectPath, probe = isMetroRunning, isFree = isPortFree) {
+	for (let attempt = 0; attempt < RESERVE_ATTEMPTS; attempt++) {
+		const port = await allocatePort(projectPath, probe, isFree);
+		const claimed = claimMetroPort(projectPath, port);
+		if (claimed !== null) return claimed;
+	}
+	throw new Error(`Could not reserve a Metro port after ${RESERVE_ATTEMPTS} attempts: another Stim run claimed each one first. Retry.`);
+}
+//#endregion
+//#region src/metro.ts
+/**
+* True when some process with this pid exists right now. It cannot tell a recycled pid from the
+* process that first held it, so it is only valid for a pid this run spawned and still holds a
+* handle on. For a pid read from a record on disk, decide with `inspectProcessIdentity` on that
+* record's process token, or take an ownership claim (`ownership-claim.ts`): this answer would keep
+* a dead holder's record looking live until some unrelated process exits.
+*/
+function pidExists(pid) {
+	if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code !== "ESRCH";
+	}
+}
+function parseLsofPids(out) {
+	if (!out) return [];
+	return String(out).split("\n").map((s) => parseInt(s.trim(), 10)).filter((n) => Number.isFinite(n));
+}
+function parseLsofCwd(out) {
+	if (!out) return null;
+	const lines = String(out).split("\n");
+	const idx = lines.findIndex((l) => l === "fcwd");
+	if (idx === -1) return null;
+	const nLine = lines.slice(idx + 1).find((l) => l.startsWith("n"));
+	return nLine ? nLine.slice(1) : null;
+}
+function processCwd(pid) {
+	if (process.platform === "linux") try {
+		return readlinkSync(`/proc/${pid}/cwd`);
+	} catch {}
+	return parseLsofCwd(getExecutor().runQuiet(`lsof -a -p ${pid} -d cwd -Fn`));
+}
+function canonicalPath(path) {
+	try {
+		return realpathSync(path);
+	} catch {
+		return path;
+	}
+}
+function isInsideProject(cwd, projectPath) {
+	if (!cwd || !projectPath) return false;
+	const a = canonicalPath(cwd);
+	const b = canonicalPath(projectPath);
+	return a === b || a.startsWith(b.endsWith(sep) ? b : b + sep);
+}
+const NOT_OURS_UNRESPONSIVE = "unresponsive";
+const NOT_OURS_UNREADABLE_CWD = "unreadable-cwd";
+const NOT_OURS_FOREIGN_CWD = "foreign-cwd";
+async function resolveProjectMetro(port, projectPath, { probe = isMetroRunning } = {}) {
+	const pid = parseLsofPids(getExecutor().runQuiet(`lsof -nP -iTCP:${port} -sTCP:LISTEN -t`))[0];
+	if (pid === void 0) return { missing: true };
+	if (!await probe(port)) return {
+		notOurs: `pid ${pid} on port ${port} does not answer Metro's /status`,
+		kind: NOT_OURS_UNRESPONSIVE,
+		pid
+	};
+	const cwd = processCwd(pid);
+	if (!cwd) return {
+		notOurs: `pid ${pid} on port ${port}: working directory could not be read`,
+		kind: NOT_OURS_UNREADABLE_CWD,
+		pid
+	};
+	if (!isInsideProject(cwd, projectPath)) return {
+		notOurs: `pid ${pid} on port ${port} runs from ${cwd}, outside ${projectPath}`,
+		kind: NOT_OURS_FOREIGN_CWD,
+		pid
+	};
+	const supervisor = readWorkspaceState(canonicalPath(projectPath))?.supervisor;
+	const owned = supervisor?.port === port && inspectProcessIdentity(supervisor) === "same";
+	return { metro: {
+		pid,
+		leader: owned ? supervisor.pid : pid,
+		cwd,
+		...owned ? { processToken: supervisor.processToken } : {}
+	} };
+}
+function killMetroTree(leader, processToken) {
+	if (!leader || leader === process.pid || inspectProcessIdentity({
+		pid: leader,
+		processToken
+	}) !== "same") return false;
+	try {
+		process.kill(-leader, "SIGTERM");
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { isMetroRunning as a, resolveProjectMetro as i, killMetroTree as n, reserveMetroPort as o, pidExists as r, NOT_OURS_FOREIGN_CWD as t };

package/dist/metro-store-CDDZHtPl.mjs

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { METRO_NAMED_CACHE_LAYOUT, metroCacheRoot, registerCache, sharedStoreRoot, tagSharedStore } from "@stim-cli/core";
+import { fileURLToPath } from "node:url";
+//#region src/supervisor/metro-store.ts
+function metroStoreName(root) {
+	try {
+		const name = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"))?.name;
+		if (typeof name === "string" && name.trim() !== "") return name;
+	} catch {}
+	return "app";
+}
+function metroStoreRoot(root) {
+	return metroCacheRoot(metroStoreName(root));
+}
+function registerMetroStore(storeRoot) {
+	const parent = resolve(metroCacheRoot());
+	const dir = resolve(storeRoot);
+	registerCache({
+		dir,
+		name: "Metro transform cache",
+		prune: "entries",
+		entriesDepth: 2,
+		layout: METRO_NAMED_CACHE_LAYOUT,
+		note: "shared Metro transforms, installed by stim start; no eviction of its own",
+		replaces: dir === parent ? [] : [{
+			dir: parent,
+			name: "Metro transform cache",
+			prune: "entries",
+			entriesDepth: 2,
+			layout: null
+		}]
+	});
+}
+function hasStoreAt(stores, storeRoot) {
+	if (!Array.isArray(stores)) return false;
+	return stores.some((s) => sharedStoreRoot(s) === storeRoot);
+}
+function appendCacheStore(config, { storeRoot, FileStore }) {
+	if (!config || typeof config !== "object") return {
+		added: false,
+		storeRoot,
+		reason: "no config to add it to"
+	};
+	const stores = config.cacheStores;
+	if (typeof stores === "function") {
+		const original = stores;
+		config.cacheStores = (cache) => {
+			const resolved = original(cache);
+			return (Array.isArray(resolved) ? resolved : []).concat([tagSharedStore(new FileStore({ root: storeRoot }), storeRoot)]);
+		};
+		return {
+			added: true,
+			storeRoot
+		};
+	}
+	if (hasStoreAt(stores, storeRoot)) return {
+		added: false,
+		storeRoot,
+		reason: "a store already points at it"
+	};
+	config.cacheStores = [...Array.isArray(stores) ? stores : [], tagSharedStore(new FileStore({ root: storeRoot }), storeRoot)];
+	return {
+		added: true,
+		storeRoot
+	};
+}
+const EXPO_ADAPTER_FILE = "expo-metro-config.cjs";
+function expoMetroConfigPath(fromUrl = import.meta.url) {
+	const here = dirname(fileURLToPath(fromUrl));
+	for (const rel of ["../shim", "../../shim"]) {
+		const candidate = resolve(here, rel, EXPO_ADAPTER_FILE);
+		if (existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+const STORE_OK_PREFIX = "stim-metro-store: sharing Metro transforms through ";
+function metroStoreConfirmedRoot(line) {
+	if (!line.startsWith(STORE_OK_PREFIX)) return null;
+	const root = line.slice(51).trim();
+	return root === "" ? null : root;
+}
+function expoMetroStoreEnv({ root, storeRoot, adapterPath, existingOverride }) {
+	return {
+		EXPO_OVERRIDE_METRO_CONFIG: adapterPath,
+		STIM_METRO_STORE: storeRoot,
+		STIM_PROJECT_ROOT: root,
+		...existingOverride ? { STIM_EXPO_METRO_CONFIG: existingOverride } : {}
+	};
+}
+//#endregion
+export { metroStoreRoot as a, metroStoreConfirmedRoot as i, expoMetroConfigPath as n, registerMetroStore as o, expoMetroStoreEnv as r, appendCacheStore as t };

package/dist/ownership-CGPart6T.mjs

@@ -0,0 +1,60 @@
+import { D as sameProcessRecord, E as inspectProcessIdentity } from "./config-CMtIaTk9.mjs";
+import { _ as writeWorkspaceState, m as withWorkspaceStateLock, p as readWorkspaceState } from "./state-CZ-ER-8d.mjs";
+import { r as pidExists } from "./metro-COslRK_F.mjs";
+import { realpathSync } from "node:fs";
+//#region src/collector/state.ts
+function collectorRoot(root) {
+	try {
+		return realpathSync(root);
+	} catch {
+		return root;
+	}
+}
+function registerCollector(root, platform, record) {
+	root = collectorRoot(root);
+	return withWorkspaceStateLock(root, () => {
+		const collectors = {
+			...readWorkspaceState(root)?.collectors,
+			[platform]: record
+		};
+		writeWorkspaceState(root, { collectors });
+		return collectors;
+	});
+}
+function unregisterCollector(root, platform, pid, processToken) {
+	root = collectorRoot(root);
+	return withWorkspaceStateLock(root, () => {
+		const collectors = { ...readWorkspaceState(root)?.collectors };
+		const record = collectors[platform];
+		if (!(platform in collectors) || record?.pid !== pid || record.processToken !== processToken) return collectors;
+		delete collectors[platform];
+		writeWorkspaceState(root, { collectors: Object.keys(collectors).length ? collectors : void 0 });
+		return collectors;
+	});
+}
+function readCollectors(root) {
+	return readWorkspaceState(collectorRoot(root))?.collectors || {};
+}
+//#endregion
+//#region src/collector/ownership.ts
+function collectorProcessTitle(platform, root) {
+	return `stim-collector-${platform} --root ${root}`;
+}
+function verifyCollectorOwnership({ pid, platform, root, isAlive = pidExists, expected }) {
+	const record = readCollectors(root)[platform];
+	if (expected !== void 0 && !sameProcessRecord(record, expected)) return {
+		status: "unverified",
+		reason: `the ${platform} collector registration changed during cleanup`
+	};
+	if (record?.pid === pid) {
+		const identity = inspectProcessIdentity(record);
+		if (identity === "same") return { status: "ours" };
+		if (identity === "gone" || identity === "different") return { status: "gone" };
+	}
+	return isAlive(pid) ? {
+		status: "unverified",
+		reason: `pid ${pid} has no verifiable identity recorded for this workspace's ${platform} collector`
+	} : { status: "gone" };
+}
+//#endregion
+export { unregisterCollector as a, registerCollector as i, verifyCollectorOwnership as n, readCollectors as r, collectorProcessTitle as t };