reverseport 0.0.0-stage → 1.2.0

package/dist/cli-runtime/application__Setup-BExVGpqG.js

@@ -0,0 +1,540 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { AnalysisError, init_analysisErrorBase } from "./providerOperationHealth-DSTcYPJe.js";
+import { compareUnicodeCodePoints, init_unicodeCodePointOrder } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-Do66qCEp.js";
+import { init_ClientRegistrationIdentity, init_SupportedClients, isOwnedClientRegistrationCommand, manualRegistrationRemediation } from "./SupportedClients-BrZ2qZVg.js";
+import { analysisErrorWithCleanupFailure, init_analysisErrorCleanup } from "./analysisErrorCleanup-DaUQNiQd.js";
+import { init_LinuxHopper, linuxHopperInstallDisclosure } from "./Doctor-CzwYS9nB.js";
+import { filterClientsNeedingConfigure, hostRemediation, init_MacHopper, init_SetupHost, macHopperInstallDisclosure, systemSetupHost } from "./SetupHost-CzzRF89z.js";
+import { join } from "node:path";
+
+//#region dist/application/SetupClients.js
+var failedConfigurationMessage, configureDetectedClients;
+function init_SetupClients() {
+	return (init_SetupClients = __esmMin((() => {
+		failedConfigurationMessage = (reason) => {
+			if (reason === "path") return "Agent configuration path could not be safely verified. Check its permissions and, if it is a symbolic link, verify that the link resolves to a regular file owned by the current user, then rerun setup.";
+			if (reason === "backup") return "Agent configuration could not be backed up, so no change was made. Check file permissions, then rerun setup.";
+			if (reason === "write") return "Agent configuration could not be updated. Check file permissions, then rerun setup.";
+			return "Agent configuration could not be verified after writing. Repair the configuration file or restore its `.rea.backup`, then rerun setup.";
+		};
+		configureDetectedClients = async (options) => {
+			let failure;
+			for (const client of options.detectedClients) {
+				const actionId = `configure_client:${client.name}`;
+				const label = client.displayName ?? client.name;
+				options.onProgress?.({
+					actionId,
+					label,
+					state: "started"
+				});
+				const result = await options.host.configureClient(client, options.providerEnvironment, options.command);
+				options.clients[client.name] = result;
+				if (result.status === "failed") {
+					failure ??= failedConfigurationMessage(result.reason);
+					options.onProgress?.({
+						actionId,
+						label,
+						state: "failed",
+						detail: failedConfigurationMessage(result.reason)
+					});
+				} else if (result.status === "configured") {
+					options.appliedActions.push(`configured_${client.name}`);
+					options.onProgress?.({
+						actionId,
+						label,
+						state: "completed"
+					});
+				} else {
+					options.onProgress?.({
+						actionId,
+						label,
+						state: "warning",
+						detail: result.status === "unchanged" ? "Already current" : "Manual configuration required"
+					});
+				}
+			}
+			return failure;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/SetupPlan.js
+var discoverSetupState, planSetupActions, setupPlan, linuxDisclosure, majorVersion, clientConfigurationDetail;
+function init_SetupPlan() {
+	return (init_SetupPlan = __esmMin((() => {
+		init_ClientRegistrationIdentity();
+		init_LinuxHopper();
+		init_MacHopper();
+		init_unicodeCodePointOrder();
+		discoverSetupState = async (input) => {
+			const { initialDoctor } = input;
+			const linuxHopperRepairNeeded = initialDoctor.checks.some(({ name, ok, detail }) => !ok && (name === "hopper-demo-runtime" || name === "hopper-version" && detail === "/opt/hopper/bin/Hopper"));
+			const linuxDistribution = input.host.platform === "linux" ? await input.host.linuxDistribution() : undefined;
+			const hopperInstallSupported = input.host.platform === "darwin" && majorVersion(await input.host.macosVersion() ?? "0") >= 12 || input.host.platform === "linux" && linuxDistribution?.supported === true;
+			const installHopper = input.forceHopperInstall || hopperInstallSupported && input.proposeHopper && (Object.keys(input.providerEnvironment).length === 0 || linuxHopperRepairNeeded);
+			const [clients, detectedClients] = await Promise.all([input.host.supportedClients(), input.host.detectedClients()]);
+			const detectedIds = new Set(detectedClients.map(({ name }) => name));
+			const registrations = initialDoctor.identity?.registrations ?? [];
+			const registrationByClient = new Map(registrations.map((registration) => [registration.client, registration]));
+			const clientStates = clients.map((client) => {
+				const registration = registrationByClient.get(client.name);
+				const ownedRegistration = (registration?.state === "aligned" || registration?.state === "stale") && isOwnedClientRegistrationCommand(registration.command);
+				const configured = ownedRegistration;
+				const status = registration?.state === "invalid" ? "invalid" : ownedRegistration && registration.state === "aligned" ? "configured" : ownedRegistration && registration.state === "stale" ? "needs_configuration" : detectedIds.has(client.name) ? "needs_configuration" : "missing";
+				return {
+					client,
+					detected: detectedIds.has(client.name),
+					configured,
+					status
+				};
+			});
+			const defaultClientIds = registrations.filter((registration) => (registration.state === "aligned" || registration.state === "stale") && isOwnedClientRegistrationCommand(registration.command)).map(({ client }) => client);
+			return {
+				initialDoctor,
+				installHopper,
+				clients,
+				detectedClientIds: [...detectedIds],
+				defaultClientIds,
+				clientStates,
+				...linuxDistribution?.packageFamily === undefined ? {} : { linuxPackageFamily: linuxDistribution.packageFamily }
+			};
+		};
+		planSetupActions = async (input) => {
+			const byId = new Map(input.discovery.clients.map((client) => [client.name, client]));
+			const unknownClient = input.clientIds.find((id) => !byId.has(id));
+			if (unknownClient !== undefined) {
+				return {
+					plannedActions: [],
+					selectedClients: [],
+					clientsToConfigure: [],
+					blocker: `Unsupported setup client: ${unknownClient}.`
+				};
+			}
+			const selectedClients = input.clientIds.flatMap((id) => {
+				const client = byId.get(id);
+				return client === undefined ? [] : [client];
+			});
+			const inspections = await Promise.all(selectedClients.map(async (client) => ({
+				client,
+				inspection: await input.host.inspectClientConfiguration(client, input.providerEnvironment, input.command)
+			})));
+			const invalid = inspections.find(({ inspection }) => inspection.status === "invalid");
+			if (invalid?.inspection.status === "invalid") {
+				return {
+					plannedActions: [],
+					selectedClients,
+					clientsToConfigure: [],
+					blocker: `${invalid.client.displayName ?? invalid.client.name}: ${invalid.inspection.remediation}`
+				};
+			}
+			const clientPlans = inspections.flatMap(({ client, inspection }) => client.format !== "unsupported" && (inspection.status === "create" || inspection.status === "update" || input.discovery.installHopper && inspection.status === "already_current") ? [{
+				client,
+				operation: inspection.status === "already_current" ? "update" : inspection.status,
+				...inspection.status !== "already_current" && inspection.backupPath !== undefined ? { backupPath: inspection.backupPath } : {}
+			}] : []);
+			return {
+				plannedActions: setupPlan({
+					platform: input.host.platform,
+					homeDirectory: input.host.homeDirectory,
+					installHopper: input.discovery.installHopper,
+					installSkill: input.installSkill,
+					skillClientIds: input.skillClientIds,
+					skillDestinations: input.host.skillDestinations(input.skillClientIds),
+					clients: clientPlans,
+					providerEnvironment: input.providerEnvironment,
+					...input.discovery.linuxPackageFamily === undefined ? {} : { linuxPackageFamily: input.discovery.linuxPackageFamily },
+					command: input.command
+				}),
+				selectedClients,
+				clientsToConfigure: selectedClients.filter((client) => clientPlans.some(({ client: planned }) => planned.name === client.name))
+			};
+		};
+		setupPlan = (input) => [
+			...input.installHopper ? [{
+				id: "install_hopper",
+				kind: "install_hopper",
+				label: "Hopper deep-analysis provider",
+				target: input.platform === "darwin" ? join(input.homeDirectory, "Applications/Hopper Disassembler.app") : "system package manager",
+				detail: input.platform === "linux" ? "Download, verify, and install Hopper plus its Xvfb demo-session dependencies. For the supported demo build, REA uses a private display and selects Hopper's offered demo mode for each analysis session." : "Download the official Hopper package, verify it, and install it. Hopper may show its demo or license prompt when first opened.",
+				external: true,
+				operation: "install",
+				...input.platform === "linux" ? input.linuxPackageFamily === undefined ? {} : linuxDisclosure(input.linuxPackageFamily) : {
+					networkOrigins: macHopperInstallDisclosure.networkOrigins,
+					commands: macHopperInstallDisclosure.commands
+				}
+			}] : [],
+			...input.clients.filter(({ client }) => client.format !== "unsupported").map(({ client, operation, backupPath }) => ({
+				id: `configure_client:${client.name}`,
+				kind: "configure_client",
+				label: client.displayName ?? client.name,
+				target: client.configPath,
+				detail: clientConfigurationDetail(client.displayName ?? client.name, input.command, input.providerEnvironment, input.installHopper),
+				external: false,
+				operation,
+				...backupPath === undefined ? {} : { backupPath }
+			})),
+			...input.installSkill ? input.skillDestinations.map(({ client, path }) => ({
+				id: client === "shared" ? "install_skill" : `install_skill:${client}`,
+				kind: "install_skill",
+				label: client === "claude_code" ? "REA skill for Claude Code" : "REA reverse-engineering skill",
+				target: path,
+				detail: client === "claude_code" ? "Install or update the REA skill in Claude Code's personal skill directory." : "Install or update the bundled REA reverse-engineering skill and on-demand references.",
+				external: false,
+				operation: "install"
+			})) : []
+		];
+		linuxDisclosure = (family) => {
+			const disclosure = linuxHopperInstallDisclosure(family, process.getuid?.() === 0);
+			return {
+				networkOrigins: [disclosure.downloadUrl],
+				commands: disclosure.commands,
+				integrity: `${String(disclosure.expectedBytes)} bytes · SHA-1 ${disclosure.expectedSha1}`
+			};
+		};
+		majorVersion = (version) => Number.parseInt(version.split(".")[0] ?? "0", 10);
+		clientConfigurationDetail = (client, command, environment, installHopper) => {
+			const entries = Object.entries(environment).sort(([left], [right]) => compareUnicodeCodePoints(left, right)).map(([name, value]) => `${name}=${value}`);
+			const environmentDetail = entries.length === 0 ? " No additional provider environment variables. Existing server environment overrides are retained." : ` Detected provider environment: ${entries.join(", ")}. Existing server environment overrides are retained; detected values replace matching keys.`;
+			const hopperDetail = installHopper ? environment.HOPPER_LAUNCHER_PATH === undefined ? " If this plan installs Hopper, REA will add HOPPER_LAUNCHER_PATH using the launcher path reported by that installation." : " The HOPPER_LAUNCHER_PATH value shown above is the current fallback; if this plan installs Hopper, REA will replace it with the launcher path reported by that installation." : "";
+			return `Add the REA MCP registration for ${client}; preserve unrelated configuration. Command: ${command.map((part) => JSON.stringify(part)).join(" ")}.${environmentDetail}${hopperDetail}`;
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/Setup.js
+var runSetup, runSetupWorkflow, installHopperAction, installSkillAction, setupFailure, emitProgress, manualClientsRemediation, combineRemediation, finalSetupRemediation, isSetupDecisionCancelled, setupCancelled, resolvedReadinessScope, summarizeDoctor, failureMessage;
+function init_Setup() {
+	return (init_Setup = __esmMin((() => {
+		init_SupportedClients();
+		init_SetupClients();
+		init_SetupPlan();
+		init_SetupHost();
+		init_analysisErrorBase();
+		init_analysisErrorCleanup();
+		init_providerCleanupError();
+		runSetup = async (options, host = systemSetupHost(), confirm) => {
+			let result;
+			let primaryFailure;
+			let threw = false;
+			try {
+				result = await runSetupWorkflow(options, host, confirm);
+			} catch (cause) {
+				threw = true;
+				primaryFailure = cause;
+			}
+			let cleanupFailure;
+			try {
+				cleanupFailure = await host.close?.();
+			} catch (cause) {
+				cleanupFailure = `Setup resource cleanup failed: ${failureMessage(cause)}`;
+			}
+			if (threw) {
+				if (cleanupFailure !== undefined && primaryFailure instanceof AnalysisError) throw analysisErrorWithCleanupFailure(primaryFailure, new ProviderCleanupError("setup", primaryFailure.cleanupResources, { reason: cleanupFailure }, { operation: "setup" }), "setup");
+				if (cleanupFailure !== undefined) throw new AggregateError([primaryFailure, new Error(cleanupFailure)], "Setup and resource cleanup failed.", { cause: primaryFailure });
+				throw primaryFailure;
+			}
+			if (result === undefined) throw new Error("Setup returned no result.");
+			if (cleanupFailure === undefined) return result;
+			return {
+				...result,
+				status: "needs_human",
+				code: result.code ?? "cleanup_failed",
+				remediation: result.remediation ? `${result.remediation} ${cleanupFailure}` : cleanupFailure
+			};
+		};
+		runSetupWorkflow = async (options, host, confirm) => {
+			const appliedActions = [];
+			let plannedActions = [];
+			const clients = {};
+			let clientStates = [];
+			let readinessScope = options.readinessScope;
+			const fail = (remediation) => setupFailure(remediation, [
+				host,
+				plannedActions,
+				appliedActions,
+				clients,
+				clientStates
+			], readinessScope);
+			const unsupported = await hostRemediation(host, false);
+			if (unsupported !== undefined) return fail(unsupported);
+			const initialState = await host.initialSetupState(options.readinessScope);
+			let { hopperPath, providerEnvironment } = initialState;
+			const discovery = await discoverSetupState({
+				host,
+				providerEnvironment,
+				forceHopperInstall: options.installHopper,
+				proposeHopper: options.proposeHopper ?? (confirm !== undefined && !options.structured),
+				initialDoctor: initialState.doctor
+			});
+			clientStates = discovery.clientStates;
+			const clientSelectionAllowed = options.clientIds === undefined && options.readinessScope?.clients === undefined && options.allDetectedClients !== true && options.installHopper !== true && options.skillClientIds === undefined && options.installSkill === undefined;
+			const interactiveSelection = confirm !== undefined && !options.structured && clientSelectionAllowed;
+			let selectedClientIds = options.allDetectedClients ? discovery.detectedClientIds : options.clientIds ?? options.readinessScope?.clients ?? discovery.defaultClientIds;
+			let selectedSkillClientIds = options.skillClientIds ?? options.readinessScope?.skillClients ?? selectedClientIds;
+			let skillNeedsInstall = await host.skillNeedsInstall(selectedSkillClientIds);
+			let skillSelected = options.installSkill === true || options.installSkill !== false && (selectedClientIds.length > 0 || selectedSkillClientIds.length > 0);
+			let installSkill = skillSelected && skillNeedsInstall;
+			let planDiscovery = discovery;
+			if (interactiveSelection) {
+				const selectionSkillClientIds = [...new Set([...discovery.defaultClientIds, ...discovery.detectedClientIds])];
+				const selectionSkillNeedsInstall = await host.skillNeedsInstall(selectionSkillClientIds);
+				const offerSkillAction = options.installSkill !== false && selectionSkillNeedsInstall;
+				const selectionActions = await planSetupActions({
+					discovery,
+					host,
+					providerEnvironment,
+					command: host.registrationCommand,
+					clientIds: [],
+					skillClientIds: selectionSkillClientIds,
+					installSkill: offerSkillAction
+				});
+				const decision = await confirm(selectionActions.plannedActions, {
+					stage: "select",
+					clientStates,
+					selectedClientIds: discovery.defaultClientIds,
+					clientSelectionAllowed
+				});
+				if (isSetupDecisionCancelled(decision)) return setupCancelled(selectionActions.plannedActions, clients, clientStates, discovery.initialDoctor);
+				const selectedActionIds = new Set(typeof decision === "boolean" ? decision ? [...selectionActions.plannedActions.map(({ id }) => id), ...discovery.defaultClientIds.map((id) => `configure_client:${id}`)] : [] : decision.selectedActionIds);
+				selectedClientIds = [...selectedActionIds].filter((id) => id.startsWith("configure_client:")).map((id) => id.slice("configure_client:".length));
+				skillNeedsInstall = await host.skillNeedsInstall(selectedClientIds);
+				const proposedInstallAction = selectionActions.plannedActions.some(({ id }) => id === "install_hopper");
+				planDiscovery = {
+					...discovery,
+					installHopper: options.installHopper || proposedInstallAction && selectedActionIds.has("install_hopper")
+				};
+				skillSelected = options.installSkill === true || selectedActionIds.has("install_skill") && selectedClientIds.length === 0 || options.installSkill !== false && selectedClientIds.length > 0;
+				installSkill = skillSelected && skillNeedsInstall;
+				selectedSkillClientIds = selectedClientIds;
+			}
+			const planned = await planSetupActions({
+				discovery: planDiscovery,
+				host,
+				providerEnvironment,
+				command: host.registrationCommand,
+				clientIds: selectedClientIds,
+				skillClientIds: selectedSkillClientIds,
+				installSkill
+			});
+			plannedActions = planned.plannedActions;
+			if (planned.blocker !== undefined) return fail(planned.blocker);
+			const hopperBlocker = await hostRemediation(host, planDiscovery.installHopper);
+			if (hopperBlocker !== undefined) return fail(hopperBlocker);
+			const planSelection = {
+				installHopper: planDiscovery.installHopper,
+				installSkill,
+				skillSelected,
+				selectedSkillClientIds,
+				selectedClients: planned.selectedClients,
+				clientsToConfigure: planned.clientsToConfigure
+			};
+			readinessScope = resolvedReadinessScope(options.readinessScope, planSelection);
+			const manualRemediation = manualClientsRemediation(planned.selectedClients);
+			if (options.dryRun === true) return {
+				status: "planned",
+				plannedActions,
+				appliedActions,
+				clients,
+				doctor: summarizeDoctor(discovery.initialDoctor),
+				clientStates,
+				...manualRemediation === undefined ? {} : { remediation: manualRemediation }
+			};
+			let approved = options.approved || plannedActions.length === 0;
+			let interactiveApproval = false;
+			if (!approved && confirm !== undefined && !options.structured) {
+				const decision = await confirm?.(plannedActions, {
+					stage: "confirm",
+					clientStates,
+					selectedClientIds,
+					clientSelectionAllowed: false
+				});
+				if (decision !== undefined) {
+					if (isSetupDecisionCancelled(decision)) return setupCancelled(plannedActions, clients, clientStates, discovery.initialDoctor);
+					approved = typeof decision === "boolean" ? decision : decision.approved;
+					interactiveApproval = approved;
+				}
+			}
+			if (!approved) return {
+				status: confirm === undefined ? "needs_confirmation" : "cancelled",
+				plannedActions,
+				appliedActions,
+				clients,
+				doctor: summarizeDoctor(discovery.initialDoctor),
+				clientStates,
+				...confirm === undefined ? { remediation: "Review the setup plan, then rerun interactively or with --yes." } : {}
+			};
+			let selectedClients = planSelection.clientsToConfigure;
+			if (planSelection.installHopper && (interactiveApproval || options.installHopper)) {
+				const install = await installHopperAction({
+					host,
+					options,
+					plannedActions,
+					appliedActions,
+					clients,
+					selectedClients,
+					providerEnvironment,
+					doctorScope: readinessScope,
+					clientStates
+				});
+				if ("failure" in install) return install.failure;
+				({hopperPath, providerEnvironment, selectedClients} = install);
+			}
+			const clientFailure = await configureDetectedClients({
+				host,
+				detectedClients: selectedClients,
+				providerEnvironment,
+				command: host.registrationCommand,
+				clients,
+				appliedActions,
+				...options.onProgress === undefined ? {} : { onProgress: options.onProgress }
+			});
+			if (clientFailure !== undefined) return fail(clientFailure);
+			if (planSelection.installSkill) {
+				const skillFailure = await installSkillAction(host, options, appliedActions, selectedSkillClientIds);
+				if (skillFailure !== undefined) {
+					return {
+						...await fail(skillFailure.remediation),
+						code: "skill_install_failed"
+					};
+				}
+			}
+			const doctor = summarizeDoctor(await host.doctor(readinessScope));
+			const remediation = combineRemediation(finalSetupRemediation(host.platform, appliedActions.includes("installed_hopper"), doctor.healthy, hopperPath), manualRemediation);
+			return {
+				status: remediation === undefined ? "ready" : "needs_human",
+				plannedActions,
+				appliedActions,
+				clients,
+				doctor,
+				clientStates,
+				...remediation === undefined ? {} : { remediation }
+			};
+		};
+		installHopperAction = async (input) => {
+			const label = "Hopper deep-analysis provider";
+			emitProgress(input.options, {
+				actionId: "install_hopper",
+				label,
+				state: "started"
+			});
+			const installed = await input.host.installHopper(input.options.installHopper);
+			if (installed.status === "failed") {
+				emitProgress(input.options, {
+					actionId: "install_hopper",
+					label,
+					state: "failed",
+					detail: installed.remediation
+				});
+				return { failure: {
+					status: "needs_human",
+					plannedActions: input.plannedActions,
+					appliedActions: input.appliedActions,
+					clients: input.clients,
+					doctor: summarizeDoctor(await input.host.doctor(input.doctorScope)),
+					clientStates: input.clientStates,
+					code: installed.code,
+					remediation: installed.remediation
+				} };
+			}
+			input.appliedActions.push("installed_hopper");
+			emitProgress(input.options, {
+				actionId: "install_hopper",
+				label,
+				state: installed.cleanupFailure === undefined ? "completed" : "warning",
+				detail: installed.cleanupFailure === undefined ? installed.launcherPath : `${installed.launcherPath}; ${installed.cleanupFailure}`
+			});
+			const providerEnvironment = {
+				...input.providerEnvironment,
+				HOPPER_LAUNCHER_PATH: installed.launcherPath
+			};
+			return {
+				hopperPath: installed.launcherPath,
+				providerEnvironment,
+				selectedClients: await filterClientsNeedingConfigure(input.host, input.selectedClients, providerEnvironment, input.host.registrationCommand)
+			};
+		};
+		installSkillAction = async (host, options, appliedActions, skillClientIds) => {
+			const label = "REA reverse-engineering skill";
+			emitProgress(options, {
+				actionId: "install_skill",
+				label,
+				state: "started"
+			});
+			const skill = await host.installSkill(skillClientIds);
+			if (!skill.ok) {
+				emitProgress(options, {
+					actionId: "install_skill",
+					label,
+					state: "failed",
+					detail: skill.error.message
+				});
+				return skill.error;
+			}
+			if (skill.value === "installed") appliedActions.push("installed_skill");
+			emitProgress(options, {
+				actionId: "install_skill",
+				label,
+				state: skill.value === "installed" ? "completed" : "warning",
+				...skill.value === "unchanged" ? { detail: "Already current" } : {}
+			});
+			return undefined;
+		};
+		setupFailure = async (remediation, [host, plannedActions, appliedActions, clients, clientStates], scope) => {
+			return {
+				status: "needs_human",
+				plannedActions,
+				appliedActions,
+				clients,
+				doctor: summarizeDoctor(await host.doctor(scope)),
+				clientStates,
+				remediation
+			};
+		};
+		emitProgress = (options, event) => options.onProgress?.(event);
+		manualClientsRemediation = (clients) => clients.map((client) => manualRegistrationRemediation(client.name)).find((remediation) => remediation !== undefined);
+		combineRemediation = (...parts) => {
+			const present = parts.filter((part) => part !== undefined && part !== "");
+			return present.length === 0 ? undefined : present.join(" ");
+		};
+		finalSetupRemediation = (platform, installedHopper, healthy, hopperPath) => {
+			if (platform === "darwin" && installedHopper) return "Open Hopper, choose its demo mode or activate a license, then rerun reverseport doctor --json.";
+			if (healthy) return undefined;
+			return hopperPath === undefined ? "Hopper is optional for non-Hopper providers. Rerun with --yes --install-hopper for deep native analysis." : "Run reverseport doctor and apply each reported remediation.";
+		};
+		isSetupDecisionCancelled = (decision) => typeof decision === "boolean" ? !decision : decision.cancelled === true;
+		setupCancelled = (plannedActions, clients, clientStates, doctor) => ({
+			status: "cancelled",
+			plannedActions,
+			appliedActions: [],
+			clients,
+			doctor: summarizeDoctor(doctor),
+			clientStates
+		});
+		resolvedReadinessScope = (requested, selection) => ({
+			clients: selection.selectedClients.map(({ name }) => name),
+			providers: selection.installHopper ? ["hopper"] : requested?.providers ?? [],
+			skill: selection.skillSelected === true || requested?.skill === true,
+			...selection.skillSelected === true || requested?.skill === true ? { skillClients: selection.selectedSkillClientIds } : {}
+		});
+		summarizeDoctor = (report) => ({
+			healthy: report.healthy,
+			environment_healthy: report.environment_healthy,
+			scope: report.scope,
+			availableProviders: [...report.hopperPath !== undefined && report.checks.filter(({ name }) => name.startsWith("hopper")).every(({ ok }) => ok) ? ["hopper"] : [], ...(report.providerInspections ?? []).filter(({ available }) => available).map(({ id }) => id)],
+			...report.hopperPath === undefined ? {} : { hopperPath: report.hopperPath },
+			...report.providerInspections === undefined ? {} : { providerInspections: report.providerInspections },
+			...report.identity === undefined ? {} : { identity: {
+				skill: report.identity.skill,
+				registrations: report.identity.registrations
+			} }
+		});
+		failureMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+	})))();
+}
+
+//#endregion
+init_Setup();
+export { runSetup };