reverseport 0.0.0-stage → 1.2.0

package/dist/cli-runtime/Doctor-CzwYS9nB.js

@@ -0,0 +1,862 @@
+import { __esmMin, __exportAll } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, SDK_IDENTITY, init_canonicalOrdering, init_identity, uniqueSorted } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { BinaryTargetError, init_configurationErrors } from "./configurationErrors-ByuF6gMR.js";
+import { analysisErrorRemediationAction, init_analysisErrorPresentation } from "./analysisErrorPresentation-DZrKL8kS.js";
+import { execFileOutput, init_ExecFileOutput } from "./ExecFileOutput-Czbj-HpV.js";
+import { homeDirectoryFromEnvironment, init_SupportedClients, init_homeDirectory, manualRegistrationRemediation } from "./SupportedClients-BrZ2qZVg.js";
+import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CZqLEfbb.js";
+import { init_BinaryTargetResolver, parseBinaryTarget } from "./BinaryTargetResolver-CKRfFhLj.js";
+import { SUPPORTED_NODE_VERSION_PROSE, init_runtimeVersion, javaScriptRuntime, supportsNodeVersion } from "./runtimeVersion-CMGd0bDu.js";
+import { CATALOG_IDENTITY, init_catalogIdentity } from "./catalogIdentity-EYVhBUYJ.js";
+import { init_SetupSkill, readInstalledSkillIdentity } from "./ClientConfigurationDocument-D0ZqgTCv.js";
+import { init_ClientRegistrationStatus, readClientRegistrationStatuses } from "./ClientRegistrationStatus-DGpwJ4ry.js";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { access, mkdtemp, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { constants, createReadStream } from "node:fs";
+import { execFile } from "node:child_process";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+
+//#region dist/application/homebrew.js
+var HOMEBREW_COMMANDS, probeHomebrew, caskDirectoriesSchema, caskConfigSchema, installedCaskAppdir;
+function init_homebrew() {
+	return (init_homebrew = __esmMin((() => {
+		HOMEBREW_COMMANDS = [
+			"brew",
+			"/opt/homebrew/bin/brew",
+			"/usr/local/bin/brew"
+		];
+		probeHomebrew = async (probe) => {
+			for (const command of HOMEBREW_COMMANDS) {
+				const result = await probe(command);
+				if (result !== undefined) return result;
+			}
+			return undefined;
+		};
+		caskDirectoriesSchema = z.object({ appdir: z.string().min(1).optional() }).loose();
+		caskConfigSchema = z.object({
+			default: caskDirectoriesSchema.optional(),
+			env: caskDirectoriesSchema.optional(),
+			explicit: caskDirectoriesSchema.optional()
+		}).loose();
+		installedCaskAppdir = async (caskroom, token, home) => {
+			let text;
+			try {
+				text = await readFile(join(caskroom, token, ".metadata", "config.json"), "utf8");
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+			let parsed;
+			try {
+				parsed = JSON.parse(text);
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+			const config = caskConfigSchema.safeParse(parsed);
+			if (!config.success) return undefined;
+			const appdir = config.data.explicit?.appdir ?? config.data.env?.appdir ?? config.data.default?.appdir;
+			if (appdir === undefined) return undefined;
+			return appdir.startsWith("~/") ? join(home, appdir.slice(2)) : appdir;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/HopperDownload.js
+var HOPPER_DOWNLOAD_BYTES, downloadHopperPackage;
+function init_HopperDownload() {
+	return (init_HopperDownload = __esmMin((() => {
+		HOPPER_DOWNLOAD_BYTES = 1e8;
+		downloadHopperPackage = async (url, options = {}) => {
+			const deadline = AbortSignal.timeout(12e4);
+			const response = await fetch(url, {
+				headers: {
+					accept: "application/json",
+					"user-agent": "rea-installer"
+				},
+				signal: options.signal === undefined ? deadline : AbortSignal.any([options.signal, deadline])
+			});
+			const refused = {
+				ok: false,
+				bytes: new Uint8Array()
+			};
+			if (!response.ok || Number(response.headers.get("content-length")) > 1e8) {
+				await response.body?.cancel();
+				return refused;
+			}
+			if (response.body === null) return {
+				ok: true,
+				bytes: new Uint8Array()
+			};
+			const reader = response.body.getReader();
+			const chunks = [];
+			let bytes = 0;
+			try {
+				while (true) {
+					const chunk = await reader.read();
+					if (chunk.done) return {
+						ok: true,
+						bytes: Buffer.concat(chunks, bytes)
+					};
+					if (chunk.value.byteLength > 1e8 - bytes) {
+						await reader.cancel();
+						return refused;
+					}
+					chunks.push(chunk.value);
+					bytes += chunk.value.byteLength;
+				}
+			} finally {
+				reader.releaseLock();
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/LinuxHopper.js
+var execFileAsync, DOWNLOAD_PREFIX, SUPPORTED_HOPPER_SHA256, SUPPORTED_RELEASES, linuxHopperInstallDisclosure, parseLinuxDistribution, readLinuxDistribution, installLinuxHopper, linuxHopperLauncherPath, systemLinuxHopperInstallHost, linuxHopperBinarySupported, linuxHopperLauncherDigestSupported, linuxSharedLibrariesAvailable, installSystemPackage, linuxPackageManagerCommands, packageIntegrityMatches, packageFamilyFor, versionAtLeast, isAbortCause;
+function init_LinuxHopper() {
+	return (init_LinuxHopper = __esmMin((() => {
+		init_ExecFileOutput();
+		init_HopperDownload();
+		execFileAsync = promisify(execFile);
+		DOWNLOAD_PREFIX = "https://www.hopperapp.com:443/downloader/public/";
+		SUPPORTED_HOPPER_SHA256 = new Set(["0294ced141cc373468ee22d8343e7dac41980cb05a937994ca81c9f09afe7ded", "1339f9e58377442b0c6fcb0dfc3cec20d593cc557408521fad9a00dbc6b8da13"]);
+		SUPPORTED_RELEASES = {
+			deb: {
+				filename: `${DOWNLOAD_PREFIX}Hopper-6.4.2-Linux-demo.deb`,
+				file_length: "35755772",
+				file_hash: "e4f79dff602648a8ff4a88b773875b6bfac0dc65"
+			},
+			rpm: {
+				filename: `${DOWNLOAD_PREFIX}Hopper-6.4.2-Linux-demo.rpm`,
+				file_length: "32264475",
+				file_hash: "b9a65f2f583a386d440d4401d9140aef3bf305de"
+			},
+			arch: {
+				filename: `${DOWNLOAD_PREFIX}Hopper-6.4.2-Linux-demo.pkg.tar.xz`,
+				file_length: "29405968",
+				file_hash: "92d780b61cab38eda95dc4112dee4fbeb0920f46"
+			}
+		};
+		linuxHopperInstallDisclosure = (family, isRoot) => {
+			const release = SUPPORTED_RELEASES[family];
+			return {
+				downloadUrl: release.filename,
+				expectedBytes: Number(release.file_length),
+				expectedSha1: release.file_hash,
+				commands: linuxPackageManagerCommands(family, `<verified-hopper.${family}>`, isRoot).map(({ executable, args }) => `${executable} ${args.join(" ")}`)
+			};
+		};
+		parseLinuxDistribution = (text) => {
+			const fields = new Map();
+			for (const line of text.split("\n")) {
+				const match = /^([A-Z_]+)=(.*)$/u.exec(line.trim());
+				if (match === null) continue;
+				const key = match[1];
+				const encoded = match[2];
+				if (key === undefined || encoded === undefined) continue;
+				const value = encoded.startsWith("\"") && encoded.endsWith("\"") ? encoded.slice(1, -1).replaceAll("\\\"", "\"").replaceAll("\\\\", "\\") : encoded;
+				fields.set(key, value);
+			}
+			const id = (fields.get("ID") ?? "unknown").toLowerCase();
+			const versionId = fields.get("VERSION_ID");
+			const packageFamily = packageFamilyFor(id, fields.get("ID_LIKE"));
+			const supported = packageFamily !== undefined && (id === "arch" || id === "cachyos" || id === "omarchy" && packageFamily === "arch" || id === "ubuntu" && versionAtLeast(versionId, 24) || id === "fedora" && versionAtLeast(versionId, 41) || id === "nobara" && versionAtLeast(versionId, 44));
+			const identity = {
+				id,
+				...versionId === undefined ? {} : { versionId }
+			};
+			return supported ? {
+				...identity,
+				packageFamily,
+				supported: true
+			} : {
+				...identity,
+				packageFamily,
+				supported: false
+			};
+		};
+		readLinuxDistribution = async () => {
+			try {
+				return parseLinuxDistribution(await readFile("/etc/os-release", "utf8"));
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+		};
+		installLinuxHopper = async (host = systemLinuxHopperInstallHost(process.env), options = {}) => {
+			if (options.signal?.aborted === true) return {
+				status: "failed",
+				reason: "cancelled"
+			};
+			const distribution = await host.distribution();
+			if (distribution?.supported !== true) return {
+				status: "failed",
+				reason: "unsupported_host"
+			};
+			let temporary;
+			try {
+				const release = (options.releases ?? SUPPORTED_RELEASES)[distribution.packageFamily];
+				const archiveDownload = await host.download(release.filename, options);
+				if (!archiveDownload.ok) return {
+					status: "failed",
+					reason: "download"
+				};
+				if (!packageIntegrityMatches(archiveDownload.bytes, release)) return {
+					status: "failed",
+					reason: "integrity"
+				};
+				temporary = await host.createTemporaryDirectory();
+				const archive = join(temporary, `hopper.${distribution.packageFamily}`);
+				await host.writeArchive(archive, archiveDownload.bytes);
+				if (!await host.installPackage(distribution.packageFamily, archive)) return {
+					status: "failed",
+					reason: "authorization_or_package_manager"
+				};
+				const launcherPath = "/opt/hopper/bin/Hopper";
+				const launcherStatus = await host.launcherStatus(launcherPath);
+				if (launcherStatus !== "ready") return {
+					status: "failed",
+					reason: launcherStatus === "missing" ? "launcher_missing" : launcherStatus
+				};
+				return {
+					status: "installed",
+					launcherPath
+				};
+			} catch (cause) {
+				if (isAbortCause(cause)) return {
+					status: "failed",
+					reason: "cancelled"
+				};
+				return {
+					status: "failed",
+					reason: "download"
+				};
+			} finally {
+				if (temporary !== undefined) await host.cleanup(temporary);
+			}
+		};
+		linuxHopperLauncherPath = (home) => join(home, ".local/share/rea/hopper/bin/Hopper");
+		systemLinuxHopperInstallHost = (environment) => ({
+			distribution: readLinuxDistribution,
+			download: downloadHopperPackage,
+			createTemporaryDirectory: () => mkdtemp(join(tmpdir(), "rea-hopper-")),
+			writeArchive: (path, bytes) => writeFile(path, bytes, { mode: 384 }),
+			installPackage: (family, archive) => installSystemPackage(family, archive, environment),
+			async launcherStatus(path) {
+				try {
+					await access(path);
+					const linked = await execFileOutput("ldd", [path], { env: environment });
+					if (!linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`)) return "runtime_dependencies";
+					return await linuxHopperBinarySupported(path) ? "ready" : "unsupported_hopper_build";
+				} catch (cause) {
+					void cause;
+					return "missing";
+				}
+			},
+			cleanup: (path) => rm(path, {
+				recursive: true,
+				force: true
+			})
+		});
+		linuxHopperBinarySupported = async (path) => {
+			try {
+				const hash = createHash("sha256");
+				for await (const chunk of createReadStream(path)) hash.update(chunk);
+				return linuxHopperLauncherDigestSupported(hash.digest("hex"));
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		linuxHopperLauncherDigestSupported = (digest) => SUPPORTED_HOPPER_SHA256.has(digest);
+		linuxSharedLibrariesAvailable = (output) => !/(?:=>\s+not found|error while loading shared libraries)/iu.test(output);
+		installSystemPackage = async (family, archive, environment) => {
+			try {
+				for (const command of linuxPackageManagerCommands(family, archive, process.getuid?.() === 0)) await execFileAsync(command.executable, command.args, { env: environment });
+				return true;
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		linuxPackageManagerCommands = (family, archive, isRoot) => {
+			const runtimeDependencies = family === "deb" ? [
+				"xvfb",
+				"xauth",
+				"python3",
+				"libx11-6",
+				"libxtst6"
+			] : family === "rpm" ? [
+				"xorg-x11-server-Xvfb",
+				"xorg-x11-xauth",
+				"python3",
+				"libX11",
+				"libXtst"
+			] : [
+				"xorg-server-xvfb",
+				"xorg-xauth",
+				"python",
+				"libx11",
+				"libxtst"
+			];
+			const commands = family === "deb" ? [[
+				"apt-get",
+				"install",
+				"-y",
+				archive,
+				...runtimeDependencies
+			]] : family === "rpm" ? [[
+				"dnf",
+				"install",
+				"-y",
+				archive,
+				...runtimeDependencies
+			]] : [[
+				"pacman",
+				"-S",
+				"--needed",
+				"--noconfirm",
+				...runtimeDependencies
+			], [
+				"pacman",
+				"-U",
+				"--noconfirm",
+				archive
+			]];
+			return commands.map((command) => {
+				const executable = isRoot ? command[0] : "pkexec";
+				if (executable === undefined) throw new Error("package command is empty");
+				return {
+					executable,
+					args: isRoot ? command.slice(1) : command
+				};
+			});
+		};
+		packageIntegrityMatches = (bytes, release) => bytes.byteLength === Number(release.file_length) && bytes.byteLength <= 1e8 && createHash("sha1").update(bytes).digest("hex") === release.file_hash;
+		packageFamilyFor = (id, idLike) => {
+			const identities = new Set([id, ...idLike?.toLowerCase().split(/\s+/u) ?? []]);
+			if (identities.has("ubuntu") || identities.has("debian")) return "deb";
+			if (identities.has("fedora") || identities.has("rhel")) return "rpm";
+			if (identities.has("arch")) return "arch";
+			return undefined;
+		};
+		versionAtLeast = (version, minimum) => version !== undefined && Number.parseInt(version.split(".")[0] ?? "0", 10) >= minimum;
+		isAbortCause = (cause) => cause instanceof Error && cause.name === "AbortError";
+	})))();
+}
+
+//#endregion
+//#region dist/application/DoctorDiagnostics.js
+var DEFAULT_HOPPER, SYSTEM_LINUX_HOPPER, collectDoctorDiagnostics, doctorHealthy, nodeCheck, hostCheck, findHopper, firstExecutable, hopperCheck, optionalHopperVersionCheck, optionalHopperDemoCheck, optionalIlspyCheck, optionalTargetCheck, check, providerDoctorChecks, unsupportedHopperRemediation, parseMajor, providerCheckName;
+function init_DoctorDiagnostics() {
+	return (init_DoctorDiagnostics = __esmMin((() => {
+		init_runtimeVersion();
+		init_LinuxHopper();
+		DEFAULT_HOPPER = "/Applications/Hopper Disassembler.app/Contents/MacOS/hopper";
+		SYSTEM_LINUX_HOPPER = "/opt/hopper/bin/Hopper";
+		collectDoctorDiagnostics = async (target, host) => {
+			const checks = [nodeCheck(host)];
+			checks.push(await hostCheck(host));
+			const hopperPath = await findHopper(host);
+			checks.push(hopperCheck(host, hopperPath));
+			const hopperVersionCheck = await optionalHopperVersionCheck(host, hopperPath);
+			if (hopperVersionCheck !== undefined) checks.push(hopperVersionCheck);
+			const providerInspections = await host.providerInspections?.();
+			if (providerInspections !== undefined) checks.push(...providerInspections.flatMap(providerDoctorChecks));
+			const ilspyCheck = await optionalIlspyCheck(host);
+			if (ilspyCheck !== undefined) checks.push(ilspyCheck);
+			const hopperDemoCheck = await optionalHopperDemoCheck(host, hopperPath);
+			if (hopperDemoCheck !== undefined) checks.push(hopperDemoCheck);
+			const targetCheck = await optionalTargetCheck(target, host);
+			if (targetCheck !== undefined) checks.push(targetCheck);
+			return {
+				checks,
+				...hopperPath === undefined ? {} : { hopperPath },
+				...providerInspections === undefined ? {} : { providerInspections }
+			};
+		};
+		doctorHealthy = (checks, providers) => {
+			if (providers.providerInspections === undefined) return checks.every(({ ok }) => ok);
+			const providerChecks = checks.filter(({ name }) => name.startsWith("hopper") || providers.providerInspections?.some((inspection) => providerCheckName(inspection.id, name)) === true);
+			const coreHealthy = checks.filter((candidate) => !providerChecks.includes(candidate)).every(({ ok }) => ok);
+			const configuredProvidersHealthy = providerChecks.filter(({ name }) => {
+				if (name.startsWith("hopper")) return providers.hopperConfigured;
+				return providers.providerInspections?.some((inspection) => inspection.configured && providerCheckName(inspection.id, name));
+			}).every(({ ok }) => ok);
+			return coreHealthy && configuredProvidersHealthy && (providers.hopperAvailable || providers.providerInspections.some(({ available }) => available));
+		};
+		nodeCheck = ({ runtime }) => {
+			const failure = {
+				remediation: `Install ${SUPPORTED_NODE_VERSION_PROSE}.`,
+				classification: "missing_dependency"
+			};
+			if (runtime.id === "node") return {
+				...check("node", supportsNodeVersion(runtime.version), runtime.version, failure),
+				details: {
+					runtime: "node",
+					version: runtime.version
+				}
+			};
+			return {
+				...check("node", supportsNodeVersion(runtime.nodeCompatibilityVersion), `Bun ${runtime.version} (Node.js ${runtime.nodeCompatibilityVersion} compatibility)`, failure),
+				details: {
+					runtime: "bun",
+					version: runtime.version,
+					node_compatibility_version: runtime.nodeCompatibilityVersion
+				}
+			};
+		};
+		hostCheck = async (host) => {
+			const macosVersion = host.platform === "darwin" ? await host.macosVersion() : undefined;
+			const linuxDistribution = host.platform === "linux" ? await host.linuxDistribution() : undefined;
+			const supported = host.platform === "darwin" && parseMajor(macosVersion) >= 12 || host.platform === "linux" && linuxDistribution?.supported === true || host.platform === "win32" && host.architecture === "x64";
+			const detail = macosVersion ?? (linuxDistribution === undefined ? `${host.platform} ${host.architecture}` : `${linuxDistribution.id} ${linuxDistribution.versionId ?? "unknown"}`);
+			return check("host", supported, detail, {
+				remediation: "REA supports macOS 12+, Ubuntu 24.04+, Fedora 41+, Nobara 44+, 64-bit Arch Linux, CachyOS, Omarchy, and the experimental Windows x64 Ghidra P0 boundary.",
+				classification: "unsupported_host"
+			});
+		};
+		findHopper = async (host) => {
+			const candidates = host.configuredHopperPath === undefined ? [
+				DEFAULT_HOPPER,
+				SYSTEM_LINUX_HOPPER,
+				linuxHopperLauncherPath(host.homeDirectory),
+				...await host.manualHopperPaths()
+			] : [host.configuredHopperPath];
+			const hopperPath = await firstExecutable(host, candidates);
+			if (hopperPath !== undefined || host.configuredHopperPath !== undefined) return hopperPath;
+			const brewCandidate = await host.brewHopperPath();
+			return firstExecutable(host, brewCandidate === undefined ? [] : [brewCandidate]);
+		};
+		firstExecutable = async (host, candidates) => {
+			for (const candidate of new Set(candidates)) if (await host.executable(candidate)) return candidate;
+			return undefined;
+		};
+		hopperCheck = (host, hopperPath) => check("hopper", hopperPath !== undefined, hopperPath ?? host.configuredHopperPath, {
+			remediation: host.configuredHopperPath === undefined ? "Run reverseport setup to install Hopper, or set HOPPER_LAUNCHER_PATH." : "Unset or update HOPPER_LAUNCHER_PATH to an executable Hopper launcher.",
+			classification: host.configuredHopperPath === undefined ? "missing_analysis_engine" : "config_drift"
+		});
+		optionalHopperVersionCheck = async (host, hopperPath) => {
+			if (host.platform !== "linux" || hopperPath === undefined) return undefined;
+			return check("hopper-version", await host.supportedLinuxHopper(hopperPath), hopperPath, {
+				remediation: unsupportedHopperRemediation(host.configuredHopperPath === hopperPath),
+				classification: "config_drift"
+			});
+		};
+		optionalHopperDemoCheck = async (host, hopperPath) => host.platform !== "linux" || hopperPath === undefined ? undefined : host.linuxDemoRuntimeCheck();
+		optionalIlspyCheck = async (host) => {
+			if (host.configuredIlspyCmdPath === undefined) return undefined;
+			const version = await host.ilspyCmdVersion?.(host.configuredIlspyCmdPath);
+			return check("ilspycmd", version !== undefined, version === undefined ? host.configuredIlspyCmdPath : `${host.configuredIlspyCmdPath} (${version})`, {
+				remediation: "Unset REA_ILSPY_CMD_PATH or point it at a runnable ilspycmd executable.",
+				classification: "config_drift"
+			});
+		};
+		optionalTargetCheck = async (target, host) => target === undefined ? undefined : host.inspectTarget !== undefined ? host.inspectTarget(target) : check("target", await host.validTarget(target), target, {
+			remediation: "Supply a readable local app or program path.",
+			classification: "config_drift"
+		});
+		check = (name, ok, detail, failure) => ({
+			name,
+			ok,
+			classification: ok ? "healthy" : failure.classification,
+			...detail === undefined ? {} : { detail },
+			...ok ? {} : { remediation: failure.remediation }
+		});
+		providerDoctorChecks = (inspection) => inspection.checks.map((candidate) => ({
+			name: candidate.name === "configuration" ? inspection.id : `${inspection.id}-${candidate.name}`,
+			ok: candidate.ok,
+			classification: candidate.ok ? "healthy" : candidate.classification,
+			detail: candidate.detail,
+			...candidate.remediation === null ? {} : { remediation: candidate.remediation }
+		}));
+		unsupportedHopperRemediation = (configured) => configured ? "Unset or update HOPPER_LAUNCHER_PATH, install the Hopper build supported by this REA release, or update REA." : "Install the Hopper build supported by this REA release, or update REA for a newer Hopper build.";
+		parseMajor = (version) => Number.parseInt(version?.split(".")[0] ?? "0", 10);
+		providerCheckName = (providerId, name) => name === providerId || name.startsWith(`${providerId}-`);
+	})))();
+}
+
+//#endregion
+//#region dist/application/DoctorScope.js
+var normalizeDoctorScope, scopeDoctorChecks, isProviderCheck, selectedProviderChecksFor, selectedRegistrationCheck, registrationCheck$1, selectedSkillCheck, doctorProviderCheckName;
+function init_DoctorScope() {
+	return (init_DoctorScope = __esmMin((() => {
+		init_canonicalOrdering();
+		init_SupportedClients();
+		normalizeDoctorScope = (requested, target) => ({
+			mode: requested === undefined ? "audit-wide" : "explicit",
+			clients: uniqueSorted(requested?.clients ?? []),
+			...requested?.skillClients === undefined ? {} : { skill_clients: uniqueSorted(requested.skillClients) },
+			providers: uniqueSorted(requested?.providers ?? []),
+			skill: requested?.skill === true,
+			target: target ?? null
+		});
+		scopeDoctorChecks = (input) => {
+			const providerChecks = input.checks.filter((candidate) => isProviderCheck(candidate.name, input.providers.providerInspections));
+			const coreChecks = input.checks.filter(({ name }) => name === "node" || input.scope.target !== null && name === "target");
+			const clientChecks = input.scope.clients.map((client) => selectedRegistrationCheck(client, input.registrations.find((candidate) => candidate.client === client)));
+			const skillChecks = input.scope.skill ? [selectedSkillCheck(input.skillState, input.checks)] : [];
+			const selectedProviderChecks = input.scope.providers.flatMap((providerId) => selectedProviderChecksFor(providerId, providerChecks, input.providers));
+			const hopperHostChecks = input.scope.providers.includes("hopper") ? input.checks.filter(({ name }) => name === "host") : [];
+			const scopeChecks = [
+				...coreChecks,
+				...hopperHostChecks,
+				...selectedProviderChecks,
+				...clientChecks,
+				...skillChecks
+			];
+			const selectedNames = new Set(scopeChecks.map(({ name }) => name));
+			return {
+				healthy: coreChecks.every(({ ok }) => ok) && hopperHostChecks.every(({ ok }) => ok) && clientChecks.every(({ ok }) => ok) && skillChecks.every(({ ok }) => ok) && selectedProviderChecks.every(({ ok }) => ok),
+				scopeChecks,
+				informationalChecks: input.checks.filter(({ name }) => !selectedNames.has(name))
+			};
+		};
+		isProviderCheck = (name, inspections) => name.startsWith("hopper") || inspections?.some(({ id }) => doctorProviderCheckName(id, name)) === true;
+		selectedProviderChecksFor = (providerId, checks, providers) => {
+			const selected = checks.filter(({ name }) => providerId === "hopper" ? name.startsWith("hopper") : doctorProviderCheckName(providerId, name));
+			const available = providerId === "hopper" ? providers.hopperAvailable : providers.providerInspections?.find(({ id }) => id === providerId)?.available === true;
+			if (available && selected.every(({ ok }) => ok)) return selected;
+			if (selected.some(({ ok }) => !ok)) return selected;
+			return [...selected, {
+				name: `provider:${providerId}`,
+				ok: false,
+				classification: "missing_analysis_engine",
+				detail: `Requested provider ${providerId} is unavailable.`,
+				remediation: `Configure the ${providerId} provider, then rerun reverseport doctor.`
+			}];
+		};
+		selectedRegistrationCheck = (client, status) => {
+			const manual = manualRegistrationRemediation(client);
+			if (status === undefined && manual !== undefined) return {
+				name: `registration:${client}`,
+				ok: false,
+				classification: "config_drift",
+				detail: `${client} is not registered through a local configuration file.`,
+				remediation: manual
+			};
+			return status === undefined ? {
+				name: `registration:${client}`,
+				ok: false,
+				classification: "config_drift",
+				detail: `Requested client ${client} was not detected.`,
+				remediation: `Install or select ${client}, then run reverseport setup --client ${client}.`
+			} : status.state === "aligned" ? {
+				name: `registration:${client}`,
+				ok: true,
+				classification: "healthy",
+				detail: status.config_path
+			} : registrationCheck$1(status);
+		};
+		registrationCheck$1 = (status) => ({
+			name: `registration:${status.client}`,
+			ok: false,
+			classification: "config_drift",
+			detail: status.config_path,
+			remediation: status.remediation
+		});
+		selectedSkillCheck = (state, checks) => checks.find(({ name }) => name === "skill:identity") ?? {
+			name: "skill:identity",
+			ok: state === "aligned",
+			classification: state === "aligned" ? "healthy" : "config_drift",
+			...state === "aligned" ? { detail: "Installed REA skill identity is aligned." } : { remediation: "Run reverseport setup to update the installed REA skill." }
+		};
+		doctorProviderCheckName = (providerId, name) => name === providerId || name.startsWith(`${providerId}-`);
+	})))();
+}
+
+//#endregion
+//#region dist/application/Doctor.js
+var Doctor_exports = /* @__PURE__ */ __exportAll({
+	runDoctor: () => runDoctor,
+	runDoctorOwned: () => runDoctorOwned,
+	systemDoctorHost: () => systemDoctorHost
+});
+var runDoctor, runDoctorOwned, inspectDoctor, closeDoctorHost, doctorReportWithCleanup, collectDoctorIdentity, skillIdentityAligned, skillIdentityCheck, registrationCheck, installationState, systemDoctorHost, readMacosVersion, executableAvailable, uncomposedLinuxDemoRuntimeCheck, manualHopperPaths, uniqueLines, firstIlspyVersionLine;
+function init_Doctor() {
+	return (init_Doctor = __esmMin((() => {
+		init_ArtifactResourceScope();
+		init_homeDirectory();
+		init_analysisErrorPresentation();
+		init_configurationErrors();
+		init_BinaryTargetResolver();
+		init_ExecFileOutput();
+		init_runtimeVersion();
+		init_homebrew();
+		init_LinuxHopper();
+		init_SetupSkill();
+		init_catalogIdentity();
+		init_identity();
+		init_ClientRegistrationStatus();
+		init_DoctorDiagnostics();
+		init_DoctorScope();
+		runDoctor = async (target, selectedHost, requestedScope) => selectedHost === undefined ? runDoctorOwned(target, systemDoctorHost(), requestedScope) : inspectDoctor(target, selectedHost, requestedScope);
+		runDoctorOwned = async (target, host, requestedScope) => {
+			let report;
+			try {
+				report = await inspectDoctor(target, host, requestedScope);
+			} catch (cause) {
+				const cleanup = await closeDoctorHost(host);
+				if (cleanup !== undefined) throw new AggregateError([cause, new Error(cleanup)], "Doctor failed and its resource cleanup remains incomplete.", { cause });
+				throw cause;
+			}
+			const cleanup = await closeDoctorHost(host);
+			return cleanup === undefined ? report : doctorReportWithCleanup(report, cleanup);
+		};
+		inspectDoctor = async (target, host, requestedScope) => {
+			const scope = normalizeDoctorScope(requestedScope, target);
+			const { checks: diagnosticChecks, hopperPath, providerInspections } = await collectDoctorDiagnostics(target, host);
+			const identity = await collectDoctorIdentity(host, scope);
+			const checks = [...diagnosticChecks, ...identity.checks];
+			const providers = {
+				hopperAvailable: hopperPath !== undefined && checks.filter(({ name }) => name.startsWith("hopper")).every(({ ok }) => ok),
+				hopperConfigured: host.configuredHopperPath !== undefined,
+				providerInspections
+			};
+			const environmentHealthy = doctorHealthy(checks, providers);
+			const scoped = scopeDoctorChecks({
+				checks,
+				registrations: identity.value.registrations,
+				skillState: identity.value.skill.state,
+				providers,
+				scope
+			});
+			return {
+				healthy: scope.mode === "audit-wide" ? environmentHealthy : scoped.healthy,
+				environment_healthy: environmentHealthy,
+				scope,
+				scope_checks: scope.mode === "audit-wide" ? checks : scoped.scopeChecks,
+				informational_checks: scope.mode === "audit-wide" ? [] : scoped.informationalChecks,
+				...hopperPath === undefined ? {} : { hopperPath },
+				...providerInspections === undefined ? {} : { providerInspections },
+				checks,
+				identity: identity.value
+			};
+		};
+		closeDoctorHost = async (host) => {
+			try {
+				return await host.close?.();
+			} catch (cause) {
+				return `Doctor host cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+			}
+		};
+		doctorReportWithCleanup = (report, detail) => {
+			const check = {
+				name: "doctor-resource-cleanup",
+				ok: false,
+				classification: "config_drift",
+				detail,
+				remediation: "Resolve the reported cleanup failure, then rerun reverseport doctor."
+			};
+			return {
+				...report,
+				healthy: false,
+				environment_healthy: false,
+				checks: [...report.checks, check],
+				scope_checks: [...report.scope_checks, check]
+			};
+		};
+		collectDoctorIdentity = async (host, scope) => {
+			const installationPaths = await host.installationPaths?.() ?? [];
+			const registrations = await host.clientRegistrations?.() ?? [];
+			const skillClientIds = scope.skill_clients ?? (scope.mode === "audit-wide" ? registrations.map(({ client }) => client) : scope.clients);
+			const installedSkillIdentity = await host.installedSkillIdentity?.(skillClientIds);
+			const skillAligned = skillIdentityAligned(installedSkillIdentity);
+			return {
+				checks: [...skillAligned ? [] : [skillIdentityCheck(installedSkillIdentity)], ...registrations.filter((registration) => registration.state !== "aligned" && registration.state !== "manual").map(registrationCheck)],
+				value: {
+					cli_package_version: PRODUCT_IDENTITY.packageVersion,
+					expected_skill_version: PRODUCT_IDENTITY.skillVersion,
+					sdk: SDK_IDENTITY,
+					catalog: CATALOG_IDENTITY,
+					live_server: {
+						state: "unknown",
+						remediation: "Call binary_session in the active client to inspect the running server identity."
+					},
+					installations: {
+						paths: installationPaths,
+						state: installationState(installationPaths)
+					},
+					skill: {
+						installed_version: installedSkillIdentity?.version ?? null,
+						installed_tool_count: installedSkillIdentity?.toolCount ?? null,
+						state: installedSkillIdentity === undefined ? "missing" : skillAligned ? "aligned" : "stale",
+						remediation: skillAligned ? null : "Run reverseport setup to update the installed REA skill."
+					},
+					registrations
+				}
+			};
+		};
+		skillIdentityAligned = (identity) => identity?.version === PRODUCT_IDENTITY.skillVersion && identity.toolCount === CATALOG_IDENTITY.counts.mcp_tools && identity.canonical;
+		skillIdentityCheck = (identity) => ({
+			name: "skill:identity",
+			ok: false,
+			classification: "config_drift",
+			detail: identity === undefined ? "Installed REA skill identity is missing." : "Installed REA skill identity is stale.",
+			remediation: "Run reverseport setup to update the installed REA skill."
+		});
+		registrationCheck = (registration) => ({
+			name: `registration:${registration.client}`,
+			ok: false,
+			classification: "config_drift",
+			detail: registration.config_path,
+			remediation: registration.remediation
+		});
+		installationState = (paths) => paths.length === 0 ? "unknown" : paths.length === 1 ? "single" : "multiple";
+		systemDoctorHost = (options = {}) => {
+			const resources = new ArtifactResourceScope();
+			const platform = options.platform ?? process.platform;
+			const architecture = options.architecture ?? process.arch;
+			const environment = options.environment ?? process.env;
+			const hostExecFileOutput = options.execFileOutput ?? execFileOutput;
+			const homeDirectory = homeDirectoryFromEnvironment(environment, platform);
+			const commandEnvironment = { env: environment };
+			return {
+				platform,
+				architecture,
+				runtime: javaScriptRuntime(process.versions),
+				homeDirectory,
+				...environment.HOPPER_LAUNCHER_PATH === undefined ? {} : { configuredHopperPath: environment.HOPPER_LAUNCHER_PATH },
+				...environment.REA_ILSPY_CMD_PATH === undefined ? {} : { configuredIlspyCmdPath: environment.REA_ILSPY_CMD_PATH },
+				macosVersion: () => readMacosVersion(hostExecFileOutput, commandEnvironment),
+				linuxDistribution: readLinuxDistribution,
+				async validTarget(path) {
+					return (await parseBinaryTarget(path, {
+						cwd: process.cwd(),
+						hostArchitecture: architecture
+					})).ok;
+				},
+				async inspectTarget(path) {
+					const result = await parseBinaryTarget(path, {
+						cwd: process.cwd(),
+						hostArchitecture: architecture
+					});
+					if (result.ok) return {
+						name: "target",
+						ok: true,
+						classification: "healthy",
+						detail: path
+					};
+					const error = result.error;
+					const targetError = error instanceof BinaryTargetError ? error : undefined;
+					return {
+						name: "target",
+						ok: false,
+						classification: targetError?.constraint !== undefined ? "unsupported_target" : "config_drift",
+						detail: path,
+						details: {
+							reason: targetError?.reason ?? error.message,
+							...targetError?.constraint === undefined ? {} : { constraint: targetError.constraint }
+						},
+						remediation: analysisErrorRemediationAction(error)
+					};
+				},
+				executable: (path) => executableAvailable(path, platform, hostExecFileOutput, commandEnvironment),
+				linuxDemoRuntimeCheck: options.linuxDemoRuntimeCheck ?? uncomposedLinuxDemoRuntimeCheck,
+				supportedLinuxHopper: linuxHopperBinarySupported,
+				async brewHopperPath() {
+					return probeHomebrew(async (command) => {
+						let caskroom;
+						try {
+							caskroom = (await hostExecFileOutput(command, ["--caskroom"], commandEnvironment)).stdout.trim();
+						} catch (cause) {
+							void cause;
+							return undefined;
+						}
+						const appdir = await installedCaskAppdir(caskroom, "hopper-disassembler", homeDirectory);
+						return appdir === undefined ? undefined : join(appdir, "Hopper Disassembler.app/Contents/MacOS/hopper");
+					});
+				},
+				manualHopperPaths: () => manualHopperPaths(homeDirectory),
+				...options.providerInspections === undefined ? {} : { providerInspections: options.providerInspections },
+				async ilspyCmdVersion(path) {
+					try {
+						await access(path, constants.X_OK);
+						return firstIlspyVersionLine((await hostExecFileOutput(path, ["--version"], {
+							timeout: 1e4,
+							...commandEnvironment
+						})).stdout);
+					} catch (cause) {
+						void cause;
+						return undefined;
+					}
+				},
+				async installationPaths() {
+					try {
+						const command = platform === "win32" ? "where" : "which";
+						const arguments_ = platform === "win32" ? ["rea"] : ["-a", "rea"];
+						return uniqueLines((await hostExecFileOutput(command, arguments_, commandEnvironment)).stdout);
+					} catch (cause) {
+						void cause;
+						return [];
+					}
+				},
+				installedSkillIdentity: (clientIds) => readInstalledSkillIdentity(homeDirectory, clientIds, environment, platform, resources),
+				close: async () => {
+					try {
+						await resources.close();
+						return undefined;
+					} catch (cause) {
+						return `Doctor resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+					}
+				},
+				clientRegistrations: () => readClientRegistrationStatuses(homeDirectory, undefined, {
+					platform,
+					environment,
+					resources
+				})
+			};
+		};
+		readMacosVersion = async (run, options) => {
+			try {
+				return (await run("sw_vers", ["-productVersion"], options)).stdout.trim();
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+		};
+		executableAvailable = async (path, platform, run, options) => {
+			try {
+				await access(path, constants.X_OK);
+				if (!(await stat(path)).isFile()) return false;
+				if (platform !== "linux") return true;
+				const linked = await run("ldd", [path], options);
+				return linuxSharedLibrariesAvailable(`${linked.stdout}\n${linked.stderr}`);
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		uncomposedLinuxDemoRuntimeCheck = () => Promise.resolve({
+			name: "hopper-demo-runtime",
+			ok: false,
+			classification: "config_drift",
+			detail: "Linux Hopper private-display diagnostics were not composed",
+			remediation: "Run reverseport doctor through the production CLI adapter."
+		});
+		manualHopperPaths = async (home) => {
+			const paths = [];
+			for (const root of ["/Applications", join(home, "Applications")]) {
+				try {
+					for (const entry of await readdir(root, { withFileTypes: true })) {
+						if (entry.isDirectory() && /^Hopper.*\.app$/i.test(entry.name)) paths.push(join(root, entry.name, "Contents/MacOS/hopper"));
+					}
+				} catch (cause) {
+					void cause;
+				}
+			}
+			return paths;
+		};
+		uniqueLines = (value) => [...new Set(value.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0))];
+		firstIlspyVersionLine = (value) => uniqueLines(value).find((line) => line.startsWith("ilspycmd:"));
+	})))();
+}
+
+//#endregion
+export { Doctor_exports, HOPPER_DOWNLOAD_BYTES, downloadHopperPackage, init_Doctor, init_HopperDownload, init_LinuxHopper, installLinuxHopper, linuxHopperInstallDisclosure, readLinuxDistribution, runDoctor, systemDoctorHost, systemLinuxHopperInstallHost };