stim 1.0.0 → 1.2.0

package/dist/error-diagnostics-Dw8Gn3yw.mjs

@@ -0,0 +1,636 @@
+import { t as getExecutor } from "./exec-CyylIdq9.mjs";
+import { f as getProject, k as withDirLock } from "./config-CMtIaTk9.mjs";
+import { f as readWorkspaceLaunches, p as readWorkspaceState } from "./state-CZ-ER-8d.mjs";
+import { n as deviceConsoleLevel } from "./ios-device-D3pzTKQE.mjs";
+import { i as resolveProjectMetro } from "./metro-COslRK_F.mjs";
+import { n as parseLogcatLine, t as androidClockOffset } from "./android-BW8i_YxU.mjs";
+import { _ as launchErrorPreview } from "./command-output-8wHMEde0.mjs";
+import { a as parseLease, n as fileLeaseIo, t as deviceLeasePath } from "./device-lease-Dpik41RY.mjs";
+import { n as androidHome } from "./android-K63_0UfF.mjs";
+import { c as readLogRecords, t as attachExpoErrorContext } from "./logs-query-oqn47Ffx.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { homedir } from "node:os";
+//#region src/diagnostic-store.ts
+/** Publishes an immutable diagnostic snapshot atomically; existing evidence wins. */
+function writeDiagnosticOnce(path, content) {
+	mkdirSync(dirname(path), { recursive: true });
+	withDirLock(`${path}.lock`, () => {
+		if (existsSync(path)) return;
+		const temporary = `${path}.${randomUUID()}.tmp`;
+		try {
+			writeFileSync(temporary, content, { flag: "wx" });
+			renameSync(temporary, path);
+		} finally {
+			try {
+				unlinkSync(temporary);
+			} catch {}
+		}
+	}, {
+		waitMs: 100,
+		pollMs: 10
+	});
+}
+//#endregion
+//#region src/native-crash.ts
+const IOS_CRASH_REPORT_RETRY = "iOS crash reports can take about a minute or longer to appear. Run `stim logs --errors` again for the native stack.";
+/** Accepts only a report for this app, simulator and launch window. */
+function parseIosCrash(text, target) {
+	try {
+		const newline = text.indexOf("\n");
+		const report = JSON.parse(text.slice(newline + 1));
+		const ts = Date.parse(report.captureTime ?? "");
+		const simulator = `com.apple.CoreSimulator.SimDevice.${target.deviceId}`;
+		if (report.bundleInfo?.CFBundleIdentifier !== target.appId || report.coalitionName !== simulator || !Number.isFinite(ts) || ts < target.since || ts > (target.until ?? Date.now() + 1e3) || !report.incident) return null;
+		const stack = ((report.threads?.find((entry) => entry.triggered) ?? report.threads?.[report.faultingThread ?? -1])?.frames ?? []).map((frame) => {
+			const image = report.usedImages?.[frame.imageIndex ?? -1];
+			return {
+				file: frame.sourceFile ?? image?.name ?? "<unknown image>",
+				line: frame.sourceLine,
+				fn: frame.symbol ? `${frame.symbol}${frame.symbolLocation ? ` + ${frame.symbolLocation}` : ""}` : `+0x${Number(frame.imageOffset ?? 0).toString(16)} [unsymbolicated]`
+			};
+		});
+		const details = [
+			report.exception?.type,
+			report.exception?.signal,
+			report.termination?.namespace,
+			report.termination?.indicator
+		].filter(Boolean).join(" / ");
+		const reasons = [
+			...report.termination?.reasons ?? [],
+			...report.termination?.details ?? [],
+			...Object.values(report.asi ?? {}).flat()
+		].filter((line) => typeof line === "string");
+		return {
+			report,
+			record: {
+				ts,
+				src: "device",
+				platform: "ios",
+				level: "fatal",
+				event: "native_crash",
+				incident: report.incident,
+				appId: target.appId,
+				deviceId: target.deviceId,
+				pid: report.pid,
+				msg: `Native crash: ${details || "process terminated"}${reasons.length ? `\n${reasons.join("\n")}` : ""}`,
+				stack,
+				rawReport: text
+			}
+		};
+	} catch {
+		return null;
+	}
+}
+/** Extracts crash-buffer groups only when their own process header names the target app. */
+function parseAndroidCrashes(text, target, clockOffsetMs) {
+	const entries = text.split("\n").map((line) => parseLogcatLine(line, { clockOffsetMs })).filter((record) => record !== null && Number(record.ts) >= target.since && Number(record.ts) <= (target.until ?? Infinity));
+	const groups = [];
+	for (const entry of entries) {
+		const last = groups.at(-1);
+		if (!last || entry.proc !== last.at(-1)?.proc || /^\s*(?:FATAL EXCEPTION:|\*\*\* \*\*\*)/.test(entry.msg ?? "")) groups.push([entry]);
+		else last.push(entry);
+	}
+	return groups.flatMap((group) => {
+		const messages = group.map((record) => record.msg ?? "");
+		const process = messages.map((line) => /^\s*(?:Process: (.+?), PID: \d+|pid: \d+, tid: \d+, name: .*?>>> (.*?) <<<)/.exec(line)).find(Boolean);
+		const appId = process?.[1] ?? process?.[2];
+		if (appId !== target.appId) return [];
+		const msg = messages.join("\n");
+		if (!/FATAL EXCEPTION:|signal \d+ \(/.test(msg)) return [];
+		return [{
+			ts: group[0].ts,
+			deviceTs: group[0].deviceTs,
+			pid: Number(/(?:PID: |pid: )(\d+)/.exec(msg)?.[1]) || void 0,
+			src: "device",
+			platform: "android",
+			level: "fatal",
+			event: "native_crash",
+			appId,
+			deviceId: target.deviceId,
+			msg: `Native crash (Android)\n${msg}`,
+			rawReport: msg
+		}];
+	});
+}
+function symbolicateIos(record, report, appPath, deadline) {
+	if (!appPath || !existsSync(appPath) || !Array.isArray(record.stack)) return record;
+	const thread = report.threads?.find((entry) => entry.triggered) ?? report.threads?.[report.faultingThread ?? -1];
+	const stack = [...record.stack];
+	const verified = /* @__PURE__ */ new Map();
+	for (const [index, frame] of (thread?.frames ?? []).entries()) {
+		if (Date.now() >= deadline) break;
+		if (frame.sourceFile && frame.sourceLine) continue;
+		const imageIndex = frame.imageIndex ?? -1;
+		const image = report.usedImages?.[imageIndex];
+		if (!image?.path || !image.uuid || !image.arch || !Number.isSafeInteger(image.base) || !Number.isSafeInteger(frame.imageOffset)) continue;
+		if (!verified.has(imageIndex)) {
+			const marker = `${basename(appPath)}/`;
+			const at = image.path.lastIndexOf(marker);
+			const relative = at < 0 ? null : image.path.slice(at + marker.length);
+			const binary = relative ? resolve(appPath, relative) : null;
+			let matched = null;
+			if (binary && binary.startsWith(resolve(appPath) + sep) && existsSync(binary)) {
+				if (getExecutor().runFileQuiet("xcrun", [
+					"dwarfdump",
+					"--uuid",
+					binary
+				], { timeoutMs: 2e3 })?.toLowerCase().includes(`uuid: ${image.uuid.toLowerCase()} (${image.arch.toLowerCase()})`)) matched = binary;
+			}
+			verified.set(imageIndex, matched);
+		}
+		const binary = verified.get(imageIndex);
+		if (!binary || Date.now() >= deadline) continue;
+		const address = image.base + frame.imageOffset;
+		if (!Number.isSafeInteger(address)) continue;
+		const output = getExecutor().runFileQuiet("xcrun", [
+			"atos",
+			"-o",
+			binary,
+			"-arch",
+			image.arch,
+			"-l",
+			`0x${image.base.toString(16)}`,
+			`0x${address.toString(16)}`
+		], { timeoutMs: 2e3 });
+		if (output && !/^0x[0-9a-f]+$/i.test(output) && !/error:|cannot|unable/i.test(output)) stack[index] = {
+			file: image.name ?? basename(binary),
+			fn: output
+		};
+	}
+	return {
+		...record,
+		stack
+	};
+}
+function symbolicateAndroid(record, root, budget) {
+	if (!root || typeof record.msg !== "string" || !/#\d+ pc /.test(record.msg)) return record;
+	const frames = [...record.msg.matchAll(/^\s*#\d+ pc ([0-9a-f]+)\s+(\S+)(.*)$/gim)];
+	const stack = frames.map(([, address, file, suffix]) => ({
+		file: basename(file),
+		fn: `${suffix?.trim() || `0x${address}`} [captured native frame]`
+	}));
+	let deadline = Math.min(Date.now() + 2e3, budget - 1e3);
+	const ndks = join(androidHome(), "ndk");
+	let tools;
+	try {
+		for (const version of readdirSync(ndks).toSorted().toReversed()) {
+			const prebuilt = join(ndks, version, "toolchains/llvm/prebuilt");
+			for (const host of readdirSync(prebuilt)) {
+				const bin = join(prebuilt, host, "bin");
+				if (existsSync(join(bin, "llvm-symbolizer"))) {
+					tools = bin;
+					break;
+				}
+			}
+			if (tools) break;
+		}
+	} catch {}
+	const files = [];
+	const visit = (directory, depth) => {
+		if (depth > 10 || files.length > 500 || Date.now() >= deadline) return;
+		try {
+			for (const entry of readdirSync(directory, { withFileTypes: true })) if (entry.isDirectory()) visit(join(directory, entry.name), depth + 1);
+			else if (entry.isFile() && entry.name.endsWith(".so")) files.push(join(directory, entry.name));
+		} catch {}
+	};
+	if (tools) {
+		for (const directory of [
+			"android/app/src/main/jniLibs",
+			"android/app/build/intermediates/cxx",
+			"android/app/.cxx"
+		]) visit(join(root, directory), 0);
+		deadline = budget;
+		const byId = /* @__PURE__ */ new Map();
+		for (const [index, [, address, file, suffix]] of frames.entries()) {
+			if (Date.now() >= deadline) break;
+			const id = /\(BuildId: ([0-9a-f]+)\)/i.exec(suffix ?? "")?.[1]?.toLowerCase();
+			if (!id) continue;
+			if (!byId.has(id)) {
+				const binary = files.filter((path) => file.endsWith(".apk") || basename(path) === basename(file)).find((path) => {
+					if (Date.now() >= deadline) return false;
+					const notes = getExecutor().runFileQuiet(join(tools, "llvm-readelf"), ["--notes", path], { timeoutMs: 1e3 });
+					return /Build ID: ([0-9a-f]+)/i.exec(notes ?? "")?.[1]?.toLowerCase() === id;
+				});
+				byId.set(id, binary ?? null);
+			}
+			const binary = byId.get(id);
+			if (!binary) continue;
+			const [fn, location] = getExecutor().runFileQuiet(join(tools, "llvm-symbolizer"), [
+				"--no-inlines",
+				"--demangle",
+				`--obj=${binary}`,
+				`0x${address}`
+			], { timeoutMs: 1e3 })?.split("\n") ?? [];
+			const match = /^(.*):(\d+):(\d+)$/.exec(location ?? "");
+			if (fn && fn !== "??" && match && match[1] !== "??" && Number(match[2]) > 0) stack[index] = {
+				fn,
+				file: match[1],
+				line: Number(match[2]),
+				column: Number(match[3])
+			};
+		}
+	}
+	const summary = record.msg.split("\n").filter((line) => /Native crash|signal \d+|Abort message:|^pid:/.test(line)).join("\n");
+	return {
+		...record,
+		msg: summary,
+		stack,
+		symbolicationNote: stack.some((frame) => !frame.line) ? "Native symbols are partial: unresolved frames retain crash-buffer symbols/addresses. Full captured report: stim logs --source device --json." : void 0
+	};
+}
+function simulatorConsolePaths(target, prepare = false, remote = false) {
+	if (remote) return void 0;
+	const container = getExecutor().runFileQuiet("xcrun", [
+		"simctl",
+		"get_app_container",
+		target.deviceId,
+		target.appId,
+		"data"
+	], { timeoutMs: 2e3 });
+	if (!container?.startsWith("/")) return void 0;
+	const directory = join(container, "Library/Caches/Stim");
+	const key = createHash("sha256").update(JSON.stringify([
+		target.deviceId,
+		target.appId,
+		target.since
+	])).digest("hex");
+	const paths = {
+		stdout: join(directory, `launch-${key}.stdout`),
+		stderr: join(directory, `launch-${key}.stderr`)
+	};
+	if (prepare) try {
+		mkdirSync(directory, { recursive: true });
+		for (const path of Object.values(paths)) writeFileSync(path, "", { flag: "wx" });
+	} catch {
+		return;
+	}
+	return paths;
+}
+function simulatorFatalConsole(target) {
+	const paths = simulatorConsolePaths(target);
+	return Object.values(paths ?? {}).flatMap((path) => {
+		try {
+			if (statSync(path).size > 8388608) return [];
+			if (target.until !== void 0 && statSync(path).mtimeMs > target.until) return [];
+			const text = readFileSync(path, "utf8");
+			const fatal = text.split("\n").filter((line) => deviceConsoleLevel(line) === "fatal");
+			if (!fatal.length) return [];
+			return [{
+				ts: Math.max(target.since + 1, statSync(path).mtimeMs),
+				src: "device",
+				platform: "ios",
+				level: "fatal",
+				event: "native_crash",
+				appId: target.appId,
+				deviceId: target.deviceId,
+				incident: basename(path),
+				pid: Number(/\[(\d+):\d+\]/.exec(text)?.[1]) || void 0,
+				msg: fatal.join("\n"),
+				rawReport: text,
+				symbolicationNote: `Captured app stderr; the full operating system crash report is not available yet. ${IOS_CRASH_REPORT_RETRY}`
+			}];
+		} catch {
+			return [];
+		}
+	});
+}
+/** Reads platform crash evidence without starting, stopping or modifying a device. */
+function captureNativeCrashes(target, logsDir) {
+	let records = [];
+	try {
+		if (target.platform === "ios" && !target.physical && process.platform === "darwin") {
+			const deadline = Date.now() + 4e3;
+			records = simulatorFatalConsole(target);
+			const directory = join(homedir(), "Library/Logs/DiagnosticReports");
+			const nativeReports = readdirSync(directory).filter((name) => name.endsWith(".ips")).map((name) => ({
+				path: join(directory, name),
+				time: statSync(join(directory, name)).mtimeMs
+			})).filter(({ time }) => time >= target.since).toSorted((a, b) => b.time - a.time).slice(0, 50).flatMap(({ path }) => {
+				if (Date.now() >= deadline) return [];
+				if (statSync(path).size > 8388608) return [];
+				const parsed = parseIosCrash(readFileSync(path, "utf8"), target);
+				return parsed ? [symbolicateIos(parsed.record, parsed.report, target.appPath, deadline)] : [];
+			});
+			if (nativeReports.length) records = nativeReports;
+		} else if (target.platform === "android") {
+			const offset = androidClockOffset(target.deviceId);
+			if (offset === null) return [];
+			const text = getExecutor().runFileQuiet("adb", [
+				"-s",
+				target.deviceId,
+				"logcat",
+				"-b",
+				"crash",
+				"-d",
+				"-v",
+				"time,epoch",
+				"-t",
+				"2000"
+			], { timeoutMs: 3e3 });
+			const deadline = Date.now() + 4e3;
+			if (text) records = parseAndroidCrashes(text, target, offset).map((record) => symbolicateAndroid(record, target.root, deadline));
+		}
+	} catch {}
+	for (const record of records) try {
+		const key = createHash("sha256").update(JSON.stringify([
+			record.deviceId,
+			record.incident ?? record.deviceTs,
+			record.rawReport
+		])).digest("hex");
+		writeDiagnosticOnce(join(logsDir, `native-crash-${key}.ndjson`), `${JSON.stringify(record)}\n`);
+	} catch {}
+	return records;
+}
+function printNativeCrashReport(target, logsDir, emit, remote) {
+	if (remote) return;
+	for (const line of launchErrorPreview(captureNativeCrashes(target, logsDir), target.root)) emit(line);
+}
+function captureWorkspaceCrashes(root, logsDir) {
+	const attempts = readLogRecords(logsDir).filter((record) => record.event === "launch_attempt");
+	const launches = readWorkspaceLaunches(root);
+	for (const platform of ["ios", "android"]) try {
+		const attempt = attempts.findLast((record) => record.platform === platform);
+		if (!attempt || attempt.remote) continue;
+		const { deviceId, appId } = attempt;
+		const since = attempt.ts;
+		const until = Date.now();
+		if (typeof deviceId !== "string" || typeof appId !== "string" || typeof since !== "number" || !Number.isFinite(since)) continue;
+		if (attempt.physical) {
+			const holder = fileLeaseIo.readHolder(root)[platform];
+			const lease = parseLease(fileLeaseIo.readLease(deviceLeasePath(platform, deviceId)));
+			if (holder?.id !== deviceId || !lease || lease.platform !== platform || lease.id !== deviceId || lease.holder !== root || lease.token !== holder.token || Date.parse(lease.expiresAt) <= until || !lease.grantedAt || !Number.isFinite(Date.parse(lease.grantedAt)) || Date.parse(lease.grantedAt) > since) continue;
+		} else {
+			const launch = launches[platform];
+			if (!launch || launch.deviceId !== deviceId || launch.appId !== appId || Date.parse(launch.launchedAt) !== since) continue;
+			const configured = getProject(root)?.platforms?.[platform];
+			if (!configured?.owned) continue;
+			if (platform === "ios" && configured.deviceUdid !== deviceId) continue;
+			if (platform === "android") {
+				if (!configured.avdName) continue;
+				if (getExecutor().runFileQuiet("adb", [
+					"-s",
+					deviceId,
+					"emu",
+					"avd",
+					"name"
+				], { timeoutMs: 2e3 })?.split("\n")[0]?.trim() !== configured.avdName) continue;
+			}
+		}
+		captureNativeCrashes({
+			root,
+			platform,
+			deviceId,
+			appId,
+			since: Number(since),
+			until,
+			physical: attempt?.physical === true,
+			appPath: attempt?.appPath ?? readWorkspaceState(root)?.lastBuild?.appPath
+		}, logsDir);
+	} catch {}
+}
+//#endregion
+//#region src/error-symbolication.ts
+const LOCATION = /https?:\/\/[^\s)'"\\]+?:\d+:\d+/g;
+function frameFromLocation(location) {
+	const match = /^(https?:\/\/.+):(\d+):(\d+)$/.exec(location);
+	if (!match) return null;
+	const file = match[1];
+	if (!/\.bundle(?:[/?]|$)/.test(file)) return null;
+	const lineNumber = Number(match[2]);
+	const column = Number(match[3]) - 1;
+	if (!Number.isSafeInteger(lineNumber) || lineNumber < 1 || !Number.isSafeInteger(column) || column < 0) return null;
+	return {
+		file,
+		lineNumber,
+		column,
+		methodName: "<unknown>"
+	};
+}
+function bundleLocations(record) {
+	const found = [...[
+		record.msg,
+		record.stack,
+		record.componentStack
+	].filter((value) => typeof value === "string").join("\n").matchAll(LOCATION)].map(([location]) => location);
+	for (const value of [record.stack, record.componentStack]) {
+		if (!Array.isArray(value)) continue;
+		for (const frame of value) if (frame && typeof frame.file === "string" && typeof frame.line === "number" && typeof frame.column === "number") found.push(`${frame.file}:${frame.line}:${frame.column + 1}`);
+	}
+	return [...new Set(found)].filter((location) => frameFromLocation(location) !== null);
+}
+/** Resolves captured bundle coordinates against the already-verified workspace Metro. */
+async function symbolicateErrors(records, { port, timeoutMs = 2e3, request = fetch }) {
+	const candidates = [...new Set(records.flatMap(bundleLocations))].slice(0, 200);
+	if (!candidates.length) return [...records];
+	const fallback = (reason) => records.map((record) => bundleLocations(record).length ? {
+		...record,
+		symbolicationNote: `JS symbolication unavailable (${reason}); captured coordinates retained.`
+	} : record);
+	if (!Number.isInteger(port) || !port || port < 1 || port > 65535) return fallback("no verified Metro");
+	try {
+		const response = await request(`http://127.0.0.1:${port}/symbolicate`, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify({ stack: candidates.map(frameFromLocation) }),
+			signal: AbortSignal.timeout(timeoutMs),
+			redirect: "error"
+		});
+		if (!response.ok) return fallback(`HTTP ${response.status}`);
+		const body = await response.json();
+		if (!Array.isArray(body.stack) || body.stack.length !== candidates.length) return fallback("invalid Metro response");
+		const resolved = /* @__PURE__ */ new Map();
+		for (let index = 0; index < candidates.length; index++) {
+			const frame = body.stack[index];
+			if (!frame || typeof frame !== "object") continue;
+			const { file, lineNumber, column } = frame;
+			if (typeof file !== "string" || /[\r\n]/.test(file) || /^https?:/.test(file) || !Number.isSafeInteger(lineNumber) || lineNumber < 1 || !Number.isSafeInteger(column) || column < 0) continue;
+			resolved.set(candidates[index], `${file}:${lineNumber}:${column + 1}`);
+		}
+		return records.map((record) => {
+			const matches = bundleLocations(record);
+			if (!matches.length) return record;
+			const replace = (value) => {
+				if (typeof value === "string") return value.replace(LOCATION, (location) => resolved.get(location) ?? location);
+				if (!Array.isArray(value)) return value;
+				return value.map((frame) => {
+					if (!frame || typeof frame !== "object") return frame;
+					const mapped = resolved.get(`${frame.file}:${frame.line}:${frame.column + 1}`);
+					const match = mapped && /^(.*):(\d+):(\d+)$/.exec(mapped);
+					return match ? {
+						...frame,
+						file: match[1],
+						line: Number(match[2]),
+						column: Number(match[3]) - 1
+					} : frame;
+				});
+			};
+			return {
+				...record,
+				...record.msg !== void 0 ? { msg: replace(record.msg) } : {},
+				...record.stack !== void 0 ? { stack: replace(record.stack) } : {},
+				...record.componentStack !== void 0 ? { componentStack: replace(record.componentStack) } : {},
+				...matches.some((location) => !resolved.has(location)) ? { symbolicationNote: "Some JS frames remain unsymbolicated; captured coordinates retained." } : {}
+			};
+		});
+	} catch {
+		return fallback("request failed or timed out");
+	}
+}
+//#endregion
+//#region src/error-diagnostics.ts
+function key(record) {
+	return createHash("sha256").update(JSON.stringify(record)).digest("hex");
+}
+function errorTitle(record) {
+	const line = String(record.msg ?? "").split("\n")[0].trim().replace(/^ERROR\s+/, "");
+	return /^(?:\{\s*)?\[?((?:\w*Error|\w*Exception): .+?)\]?$/.exec(line)?.[1] ?? null;
+}
+function identity(record) {
+	return JSON.stringify([
+		record.src,
+		record.ts,
+		record.proc,
+		record.msg
+	]);
+}
+function attachDeviceErrorContext(timeline, selected) {
+	const consumed = /* @__PURE__ */ new Set();
+	return selected.map((record) => {
+		if (record.src !== "device" || !record.proc) return record;
+		if (!errorTitle(record) && !/^\s+at\s+\S/.test(record.msg ?? "")) return record;
+		const index = timeline.findIndex((entry) => identity(entry) === identity(record));
+		if (index < 0) return record;
+		const context = [];
+		for (const next of timeline.slice(index + 1)) {
+			if (Number(next.ts) - Number(record.ts) > 1e3 || context.length >= 200) break;
+			if (next.src !== "device" || next.proc !== record.proc || next.platform !== record.platform) continue;
+			if (!/^\s*(?:(?:componentStack|stack):\s*['"]|isComponentError:|[{}],?$|at\s+\S)/.test(next.msg ?? "")) break;
+			context.push(String(next.msg));
+			consumed.add(identity(next));
+		}
+		return context.length ? {
+			...record,
+			msg: [record.msg, ...context].join("\n")
+		} : record;
+	}).filter((_record, index) => !consumed.has(identity(selected[index])));
+}
+/** Collapses only cross-source copies with the same error title and a shared stack location. */
+function mergeErrorCopies(records, root) {
+	const result = [];
+	for (const record of records) {
+		if (record.event === "native_crash" && record.pid) {
+			const duplicate = result.findIndex((other) => other.event === "native_crash" && other.pid === record.pid && other.deviceId === record.deviceId && other.appId === record.appId && Math.abs(Number(other.ts) - Number(record.ts)) < 5e3);
+			if (duplicate >= 0) {
+				const prior = result[duplicate];
+				const full = Array.isArray(record.stack) ? record : prior;
+				const consoleRecord = full === record ? prior : record;
+				result[duplicate] = {
+					...full,
+					msg: full.msg === consoleRecord.msg ? full.msg : `${consoleRecord.msg}\n${full.msg}`
+				};
+				continue;
+			}
+		}
+		const title = errorTitle(record);
+		const locations = new Set([...JSON.stringify([
+			record.msg,
+			record.stack,
+			record.componentStack
+		]).replaceAll(root ? `${root}/` : "\0", "").matchAll(/[^\s()"\\]+:\d+:\d+/g)].map(([location]) => location));
+		const existing = title && locations.size ? result.findIndex((other) => !(Array.isArray(other.mirroredSources) ? other.mirroredSources : [other.src]).includes(record.src) && (!other.platform || !record.platform || other.platform === record.platform) && errorTitle(other) === title && typeof other.ts === "number" && typeof record.ts === "number" && Math.abs(other.ts - record.ts) < 1e3 && [...JSON.stringify([
+			other.msg,
+			other.stack,
+			other.componentStack
+		]).replaceAll(root ? `${root}/` : "\0", "").matchAll(/[^\s()"\\]+:\d+:\d+/g)].some(([location]) => locations.has(location))) : -1;
+		if (existing < 0) result.push(record);
+		else {
+			const prior = result[existing];
+			const richer = JSON.stringify(record).length > JSON.stringify(prior).length ? record : prior;
+			const other = richer === record ? prior : record;
+			const sources = [.../* @__PURE__ */ new Set([...Array.isArray(prior.mirroredSources) ? prior.mirroredSources : [prior.src], record.src])];
+			result[existing] = {
+				...richer,
+				src: prior.src,
+				ts: prior.ts,
+				platform: prior.platform ?? record.platform,
+				...richer.stack || other.stack ? { stack: richer.stack ?? other.stack } : {},
+				...richer.componentStack || other.componentStack ? { componentStack: richer.componentStack ?? other.componentStack } : {},
+				msg: /\bCall Stack\b/.test(String(other.msg)) && /componentStack/.test(String(richer.msg)) ? `${other.msg}\n${String(richer.msg).replace(/^[^\n]*\n/, "")}` : richer.msg,
+				mirroredSources: sources,
+				symbolicationNote: [richer.symbolicationNote, `Same error captured by ${sources.join(" + ")}; raw copies retained in logs --json.`].filter(Boolean).join(" ")
+			};
+		}
+	}
+	return result;
+}
+/** Keeps symbolicated launch evidence stable when Metro later rebuilds or stops. */
+async function errorDiagnostics(input, { root, logsDir, port, allowRequest = false }) {
+	const timeline = readLogRecords(logsDir);
+	const records = attachDeviceErrorContext(timeline, attachExpoErrorContext(timeline, input.map((record) => ({
+		...record,
+		src: typeof record.src === "string" ? record.src : void 0,
+		msg: record.msg == null ? void 0 : String(record.msg),
+		level: typeof record.level === "string" ? record.level : void 0,
+		ts: typeof record.ts === "number" ? record.ts : void 0
+	}))));
+	const requestedCount = records.length;
+	const related = timeline.filter((candidate) => candidate.src === "device" && records.some((record) => record.src !== "device" && errorTitle(record) && errorTitle(record) === errorTitle(candidate) && Math.abs(Number(record.ts) - Number(candidate.ts)) < 1e3 && (!record.platform || !candidate.platform || record.platform === candidate.platform)) && !records.some((record) => record.src === candidate.src && record.ts === candidate.ts && record.msg === candidate.msg)).slice(-100);
+	records.push(...attachDeviceErrorContext(timeline, related));
+	const directory = join(logsDir, "error-context");
+	const rendered = records.map((record) => {
+		try {
+			const saved = JSON.parse(readFileSync(join(directory, `${key(record)}.json`), "utf8"));
+			return saved.original === key(record) && saved.rendered && typeof saved.rendered === "object" ? saved.rendered : record;
+		} catch {
+			return record;
+		}
+	});
+	const pending = records.flatMap((record, index) => {
+		if (rendered[index] !== record || !bundleLocations(record).length) return [];
+		if (timeline.some((event) => ([
+			"bundle_build_started",
+			"bundle_build_done",
+			"bundle_build_failed",
+			"server_started",
+			"supervisor_started",
+			"bundle_response_started",
+			"bundle_response_finished",
+			"bundle_response_failed"
+		].includes(String(event.event)) || ["expo_stdout", "expo_stderr"].includes(String(event.event)) && /\bBundl(?:ing|ed)\b/.test(event.msg ?? "")) && Number(event.ts) > Number(record.ts) && (!event.platform || !record.platform || event.platform === record.platform))) {
+			rendered[index] = {
+				...record,
+				symbolicationNote: "Metro rebuilt after this error; captured coordinates retained rather than mapping against a different bundle."
+			};
+			return [];
+		}
+		return [{
+			record,
+			index
+		}];
+	});
+	if (pending.length && allowRequest && port && (await resolveProjectMetro(port, root)).metro) {
+		const resolved = await symbolicateErrors(pending.map(({ record }) => record), { port });
+		for (let index = 0; index < pending.length; index++) {
+			const entry = pending[index];
+			const value = resolved[index];
+			rendered[entry.index] = value;
+			if (bundleLocations(value).length === bundleLocations(entry.record).length) continue;
+			try {
+				writeDiagnosticOnce(join(directory, `${key(entry.record)}.json`), JSON.stringify({
+					original: key(entry.record),
+					rendered: value
+				}));
+			} catch {}
+		}
+	}
+	let merged = mergeErrorCopies(rendered.slice(0, requestedCount), root);
+	for (const candidate of rendered.slice(requestedCount)) {
+		const combined = mergeErrorCopies([...merged, candidate], root);
+		if (combined.length === merged.length) merged = combined;
+	}
+	return merged;
+}
+//#endregion
+export { printNativeCrashReport as a, captureWorkspaceCrashes as i, IOS_CRASH_REPORT_RETRY as n, simulatorConsolePaths as o, captureNativeCrashes as r, errorDiagnostics as t };

package/dist/{exec-bsN9MJXb.mjs → exec-CyylIdq9.mjs}

@@ -2,7 +2,7 @@ import { execFileSync, execSync, spawn } from "child_process";
 //#region src/exec.ts
 const MAX_BUFFER = 67108864;
 let active = {
-	run(cmd, { timeoutMs, cwd } = {}) {
+	run(cmd, { timeoutMs, killSignal, cwd } = {}) {
 		const opts = {
 			encoding: "utf-8",
 			stdio: [
@@ -13,10 +13,11 @@ let active = {
 			maxBuffer: MAX_BUFFER
 		};
 		if (timeoutMs) opts.timeout = timeoutMs;
+		if (killSignal) opts.killSignal = killSignal;
 		if (cwd) opts.cwd = cwd;
 		return String(execSync(cmd, opts)).trim();
 	},
-	runFile(file, args = [], { timeoutMs, cwd, env, omitEnv } = {}) {
+	runFile(file, args = [], { timeoutMs, killSignal, cwd, env, omitEnv } = {}) {
 		const opts = {
 			encoding: "utf-8",
 			stdio: [
@@ -27,6 +28,7 @@ let active = {
 			maxBuffer: MAX_BUFFER
 		};
 		if (timeoutMs) opts.timeout = timeoutMs;
+		if (killSignal) opts.killSignal = killSignal;
 		if (cwd) opts.cwd = cwd;
 		if (env || omitEnv?.length) {
 			const childEnv = {