rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{doctorRuntime-BE5ZX8it.js → doctorRuntime-B__SIpm-.js}

@@ -1,8 +1,15 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { init_PrivateRuntimeRoot, init_WindowsAuthority, inspectWindowsNativeReadiness, privateRuntimeRootCapability } from "./PrivateRuntimeRoot-DAy0PiBM.js";
-import { JADX_FAILURE_KINDS, init_JadxConfiguration, init_JebMcpEndpoint, inspectJadxAvailability, parseJebMcpEndpoint, projectJadxFailureOutcome } from "./JebMcpEndpoint-DUytrn5G.js";
-import { init_Doctor, systemDoctorHost } from "./Doctor-DIpf_I7N.js";
-import { init_GhidraInstallation, init_IdaConfiguration, init_LinuxPrivateDisplayProbe, inspectGhidraInstallation, readIdaConfiguration, selectLinuxPrivateDisplayStrategy } from "./IdaConfiguration-CtGP7EKo.js";
+import { init_result, ok } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { RegularFileCleanupFailure, init_OwnedRegularFile } from "./OwnedRegularFile-D1f5nUCx.js";
+import { init_analysisErrorProjection, projectAnalysisError } from "./cliResultOutput-10sd6xGx.js";
+import { init_PrivateRuntimeRoot, init_WindowsAuthority, inspectWindowsNativeReadiness, privateRuntimeRootCapability } from "./PrivateRuntimeRoot-Cd23u6jd.js";
+import { analysisClientFailureForOperation, init_AnalysisClientFailure } from "./OwnedCommandCleanup-BN_V6Erc.js";
+import { JADX_FAILURE_KINDS, init_JadxConfiguration, init_JebMcpEndpoint, inspectJadxAvailability, parseJebMcpEndpoint, projectJadxFailureOutcome } from "./JebMcpEndpoint-BEalGZh9.js";
+import { init_Doctor, systemDoctorHost } from "./Doctor-DrkWsav4.js";
+import { KUNA_COMMAND_REMEDIATION, KUNA_PROVIDER_ID, KUNA_UNSUPPORTED_HOST_REMEDIATION, KUNA_VERIFIED_VERSION, KUNA_VERSION_PROBE_REMEDIATION, init_GhidraInstallation, init_IdaConfiguration, init_KunaConfiguration, init_KunaInstallation, init_KunaRelease, init_LinuxPrivateDisplayProbe, inspectGhidraInstallation, inspectKunaInstallation, readIdaConfiguration, readKunaConfiguration, selectLinuxPrivateDisplayStrategy } from "./KunaInstallation-P0j3x851.js";
+import { dirname } from "node:path";
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
 //#region dist/android/JadxDoctor.js
@@ -10,9 +17,12 @@ var inspectJadxProvider, optionalEntry, configurationCheck, windowsNativeFailure
 function init_JadxDoctor() {
 	return (init_JadxDoctor = __esmMin((() => {
 		init_JadxConfiguration();
-		inspectJadxProvider = async (environment) => {
+		inspectJadxProvider = async (environment, resourceOwner, signal) => {
 			const configured = environment.REA_JADX_MCP_JAR !== undefined;
-			const availability = await inspectJadxAvailability(environment);
+			const availability = await inspectJadxAvailability(environment, {
+				resourceOwner,
+				signal
+			});
 			const jarPath = availability.status === "available" && typeof availability.diagnostics["jar_path"] === "string" ? availability.diagnostics["jar_path"] : undefined;
 			const available = availability.status === "available" && jarPath !== undefined;
 			const configuredJar = environment.REA_JADX_MCP_JAR;
@@ -25,7 +35,8 @@ function init_JadxDoctor() {
 					REA_JADX_MCP_JAR: configuredJar,
 					...optionalEntry("JAVA_HOME", environment.JAVA_HOME),
 					...optionalEntry("REA_JADX_HEAP_MIB", environment.REA_JADX_HEAP_MIB),
-					...optionalEntry("REA_JADX_ACTIVE_PROCESSOR_COUNT", environment.REA_JADX_ACTIVE_PROCESSOR_COUNT)
+					...optionalEntry("REA_JADX_ACTIVE_PROCESSOR_COUNT", environment.REA_JADX_ACTIVE_PROCESSOR_COUNT),
+					...optionalEntry("REA_JADX_OPERATION_TIMEOUT_MS", environment.REA_JADX_OPERATION_TIMEOUT_MS)
 				},
 				checks: [configurationCheck(configured, availability, jarPath)]
 			};
@@ -34,13 +45,15 @@ function init_JadxDoctor() {
 		configurationCheck = (configured, availability, jarPath) => {
 			const code = availability.status === "unavailable" ? availability.code : null;
 			if (availability.status === "available" && jarPath !== undefined) {
+				const operationTimeout = availability.diagnostics["operation_timeout_ms"];
 				return {
 					name: "configuration",
 					ok: true,
 					code: null,
-					detail: `JADX MCP bridge JAR validated at ${jarPath}; its path is recorded for agent registrations.`,
+					detail: `JADX MCP bridge JAR validated at ${jarPath}; its path is recorded for agent registrations. This checks configuration, not whether a selected APK fits in the worker's memory.`,
 					remediation: null,
-					classification: "config_drift"
+					classification: "config_drift",
+					...typeof operationTimeout === "number" ? { details: { operation_timeout_ms: operationTimeout } } : {}
 				};
 			}
 			const kind = availability.status === "unavailable" ? asFailureKind(availability.diagnostics["failure_kind"]) : null;
@@ -92,6 +105,8 @@ function init_JadxDoctor() {
 var projectGhidraDoctorInspection, inspectSystemGhidraProvider, selectedChecks, projectCheck;
 function init_GhidraDoctor() {
 	return (init_GhidraDoctor = __esmMin((() => {
+		init_analysisErrorProjection();
+		init_AnalysisClientFailure();
 		init_WindowsAuthority();
 		init_GhidraInstallation();
 		projectGhidraDoctorInspection = (inspection) => {
@@ -106,7 +121,7 @@ function init_GhidraDoctor() {
 					GHIDRA_INSTALL_DIR: inspection.installDir,
 					JAVA_HOME: inspection.javaHome
 				} : {},
-				checks: [...selectedChecks(inspection).map((check) => projectCheck(check, inspection.installDir !== null)), ...readiness !== undefined ? [{
+				checks: [...selectedChecks(inspection).map((check) => projectCheck(check, inspection.installDir !== null, inspection.javaProbeFailure, inspection.nativeDecompilerHeaderFailure)), ...readiness !== undefined ? [{
 					name: "native_authority",
 					ok: !windowsAuthorityUnavailable,
 					code: !readiness.available ? readiness.code : null,
@@ -116,11 +131,19 @@ function init_GhidraDoctor() {
 				}] : []]
 			};
 		};
-		inspectSystemGhidraProvider = (environment) => Promise.resolve(projectGhidraDoctorInspection(inspectGhidraInstallation({
-			environment,
-			...environment.GHIDRA_INSTALL_DIR === undefined ? {} : { installDir: environment.GHIDRA_INSTALL_DIR },
-			...environment.JAVA_HOME === undefined ? {} : { javaHome: environment.JAVA_HOME }
-		})));
+		inspectSystemGhidraProvider = async (environment, resourceOwner, signal) => {
+			try {
+				return projectGhidraDoctorInspection(await inspectGhidraInstallation({
+					environment,
+					resourceOwner,
+					...signal === undefined ? {} : { signal },
+					...environment.GHIDRA_INSTALL_DIR === undefined ? {} : { installDir: environment.GHIDRA_INSTALL_DIR },
+					...environment.JAVA_HOME === undefined ? {} : { javaHome: environment.JAVA_HOME }
+				}));
+			} catch (cause) {
+				throw analysisClientFailureForOperation(cause, "ghidra", "doctor");
+			}
+		};
 		selectedChecks = (inspection) => {
 			const byName = new Map(inspection.checks.map((candidate) => [candidate.name, candidate]));
 			const configuration = byName.get("configuration");
@@ -140,13 +163,19 @@ function init_GhidraDoctor() {
 				byName.get("java")
 			].filter((candidate) => Boolean(candidate));
 		};
-		projectCheck = (check, configured) => ({
+		projectCheck = (check, configured, javaFailure, headerFailure) => ({
 			name: check.name,
 			ok: check.status === "passed",
 			code: check.status === "failed" ? check.code : null,
 			detail: check.detail,
+			...check.name === "java" && javaFailure?.output !== undefined ? { details: {
+				output: { ...javaFailure.output },
+				...javaFailure.processErrorCode === undefined ? {} : { process_error_code: javaFailure.processErrorCode },
+				...javaFailure.properties === undefined ? {} : { properties: { ...javaFailure.properties } }
+			} } : {},
+			...check.name === "native_decompiler" && headerFailure !== undefined ? { details: { header_failure: projectAnalysisError(headerFailure) } } : {},
 			remediation: check.status === "failed" ? check.remediation : null,
-			classification: check.name === "platform" || check.name === "architecture" ? "unsupported_host" : check.name === "java" && check.status === "failed" && check.code === "runtime_missing" ? "missing_dependency" : configured ? "config_drift" : "missing_analysis_engine"
+			classification: check.name === "platform" || check.name === "architecture" ? "unsupported_host" : check.name === "java" && check.status === "failed" && check.code === "runtime_missing" ? "missing_dependency" : check.name === "java" && check.status === "failed" && check.code === "runtime_unavailable" ? "runtime_failure" : configured ? "config_drift" : "missing_analysis_engine"
 		});
 	})))();
 }
@@ -192,6 +221,184 @@ function init_IdaDoctor() {
 	})))();
 }
 
+//#endregion
+//#region dist/kuna/KunaDoctor.js
+var REGISTRATION_SETTINGS, inspectKunaProvider, installationFailure, cacheCheck, nearestDirectoryWritable;
+function init_KunaDoctor() {
+	return (init_KunaDoctor = __esmMin((() => {
+		init_KunaConfiguration();
+		init_OwnedRegularFile();
+		init_KunaInstallation();
+		init_KunaRelease();
+		REGISTRATION_SETTINGS = [
+			"REA_KUNA_COMMAND",
+			"REA_KUNA_CACHE_DIR",
+			"REA_KUNA_CACHE_MAX_BYTES",
+			"REA_KUNA_PROJECT_TIMEOUT_MS",
+			"REA_KUNA_TIMEOUT_MS",
+			"REA_KUNA_JOBS"
+		];
+		inspectKunaProvider = async (environment, platform = process.platform, options) => {
+			let installation;
+			try {
+				installation = await inspectKunaInstallation(environment, {
+					platform,
+					fileCloseResources: options.fileCloseResources
+				});
+			} catch (cause) {
+				if (!(cause instanceof RegularFileCleanupFailure)) throw cause;
+				return {
+					id: KUNA_PROVIDER_ID,
+					configured: environment.REA_KUNA_COMMAND !== undefined,
+					available: false,
+					providerVersion: null,
+					registrationEnvironment: {},
+					checks: [{
+						name: "installation",
+						ok: false,
+						code: "cleanup_incomplete",
+						detail: `Kuna installation inspection could not confirm file cleanup: ${cause instanceof Error ? cause.message : String(cause)}`,
+						remediation: null,
+						classification: "config_drift",
+						details: { cleanup_incomplete: true }
+					}]
+				};
+			}
+			const configured = environment.REA_KUNA_COMMAND !== undefined && environment.REA_KUNA_COMMAND.length > 0;
+			if (!installation.ok) return {
+				id: KUNA_PROVIDER_ID,
+				configured,
+				available: false,
+				providerVersion: null,
+				registrationEnvironment: {},
+				checks: [installationFailure(installation.error, configured)]
+			};
+			const { value } = installation;
+			return {
+				id: KUNA_PROVIDER_ID,
+				configured,
+				available: true,
+				providerVersion: value.version,
+				registrationEnvironment: Object.fromEntries(REGISTRATION_SETTINGS.flatMap((name) => {
+					const setting = environment[name];
+					return setting === undefined ? [] : [[name, setting]];
+				})),
+				checks: [{
+					name: "installation",
+					ok: true,
+					code: null,
+					detail: `${value.executable} reports Kuna ${value.version} (sha256 ${value.sha256})${value.verified ? "." : `; REA verified ${KUNA_VERIFIED_VERSION}, so this release's project layout is unverified.`}`,
+					remediation: null,
+					classification: "config_drift",
+					details: {
+						executable: value.executable,
+						version: value.version,
+						verified_version: KUNA_VERIFIED_VERSION,
+						sha256: value.sha256
+					}
+				}, await cacheCheck(environment, platform)]
+			};
+		};
+		installationFailure = (failure, configured) => ({
+			name: "installation",
+			ok: false,
+			code: failure.code,
+			detail: failure.reason,
+			remediation: failure.code === "unsupported_host" ? KUNA_UNSUPPORTED_HOST_REMEDIATION : failure.code === "version_unresolved" ? KUNA_VERSION_PROBE_REMEDIATION : KUNA_COMMAND_REMEDIATION,
+			classification: failure.code === "unsupported_host" ? "unsupported_host" : configured ? "config_drift" : "missing_analysis_engine",
+			details: failure.diagnostics
+		});
+		cacheCheck = async (environment, platform) => {
+			const configuration = readKunaConfiguration(environment, platform);
+			if (!configuration.ok) return {
+				name: "cache",
+				ok: false,
+				code: configuration.error.code,
+				detail: configuration.error.reason,
+				remediation: KUNA_COMMAND_REMEDIATION,
+				classification: "config_drift"
+			};
+			const { cacheRoot, cacheMaxBytes } = configuration.value;
+			const details = {
+				cache_root: cacheRoot,
+				cache_max_bytes: cacheMaxBytes
+			};
+			try {
+				if (!(await stat(cacheRoot)).isDirectory()) return {
+					name: "cache",
+					ok: false,
+					code: "open_options_invalid",
+					detail: `The Kuna cache root ${cacheRoot} exists but is not a directory.`,
+					remediation: "Set REA_KUNA_CACHE_DIR to a directory REA may own, or remove the conflicting file.",
+					classification: "config_drift",
+					details
+				};
+				await access(cacheRoot, constants.W_OK | constants.X_OK);
+			} catch (cause) {
+				if (cause instanceof Error && "code" in cause && cause.code === "ENOENT") {
+					const creatable = await nearestDirectoryWritable(cacheRoot);
+					return creatable.ok ? {
+						name: "cache",
+						ok: true,
+						code: null,
+						detail: `REA creates the Kuna project cache at ${cacheRoot} on first use.`,
+						remediation: null,
+						classification: "config_drift",
+						details
+					} : {
+						name: "cache",
+						ok: false,
+						code: "open_options_invalid",
+						detail: `REA cannot create the Kuna cache root ${cacheRoot}: ${creatable.reason}`,
+						remediation: "Set REA_KUNA_CACHE_DIR to a directory the REA process user can create or write.",
+						classification: "config_drift",
+						details
+					};
+				}
+				return {
+					name: "cache",
+					ok: false,
+					code: "open_options_invalid",
+					detail: `REA cannot write the Kuna cache root ${cacheRoot}: ${cause instanceof Error ? cause.message : String(cause)}`,
+					remediation: "Set REA_KUNA_CACHE_DIR to a directory the REA process user can write.",
+					classification: "config_drift",
+					details
+				};
+			}
+			return {
+				name: "cache",
+				ok: true,
+				code: null,
+				detail: `Kuna project exports are cached in ${cacheRoot} (at most ${String(cacheMaxBytes)} bytes).`,
+				remediation: null,
+				classification: "config_drift",
+				details
+			};
+		};
+		nearestDirectoryWritable = async (path) => {
+			let candidate = dirname(path);
+			for (;;) {
+				try {
+					if (!(await stat(candidate)).isDirectory()) return {
+						ok: false,
+						reason: `${candidate} is not a directory.`
+					};
+					await access(candidate, constants.W_OK | constants.X_OK);
+					return { ok: true };
+				} catch (cause) {
+					const missing = cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+					const parent = dirname(candidate);
+					if (!missing || parent === candidate) return {
+						ok: false,
+						reason: `${candidate} is not writable: ${cause instanceof Error ? cause.message : String(cause)}`
+					};
+					candidate = parent;
+				}
+			}
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/doctorRuntime.js
 var createSystemDoctorHost, HOPPER_DEMO_HELPER_PATH, inspectLinuxPrivateDisplay;
@@ -201,18 +408,31 @@ function init_doctorRuntime() {
 		init_JadxDoctor();
 		init_GhidraDoctor();
 		init_IdaDoctor();
+		init_KunaDoctor();
+		init_IdaConfiguration();
 		init_JebMcpEndpoint();
 		init_LinuxPrivateDisplayProbe();
-		createSystemDoctorHost = (environment = process.env) => {
+		init_result();
+		createSystemDoctorHost = (environment = process.env, signal) => {
 			const selectedJebEndpoint = environment.REA_JEB_MCP_URL;
 			const selectedJebRegistrationEnvironment = selectedJebEndpoint !== undefined && selectedJebEndpoint.length > 0 && parseJebMcpEndpoint(selectedJebEndpoint).ok ? { REA_JEB_MCP_URL: selectedJebEndpoint } : {};
 			return systemDoctorHost({
 				environment,
+				...signal === undefined ? {} : { signal },
 				providerRegistrationEnvironment: () => selectedJebRegistrationEnvironment,
-				providerInspections: async () => [
-					await inspectSystemGhidraProvider(environment),
+				resolveProviderRequestBudget: (analysisProvider, registrationEnvironment) => {
+					if (analysisProvider !== "ida" && analysisProvider !== "auto") return ok(undefined);
+					const path = registrationEnvironment.REA_IDA_MCP_CONFIG;
+					if (path === undefined) return ok(undefined);
+					const registration = readIdaConfiguration(path);
+					if (registration.ok) return ok(registration.value.timeoutMs);
+					return analysisProvider === "ida" ? registration : ok(undefined);
+				},
+				providerInspections: async (fileCloseResources, inspectionSignal) => [
+					await inspectSystemGhidraProvider(environment, fileCloseResources, inspectionSignal),
 					inspectIdaRegistration(environment.REA_IDA_MCP_CONFIG),
-					await inspectJadxProvider(environment)
+					await inspectJadxProvider(environment, fileCloseResources, inspectionSignal),
+					await inspectKunaProvider(environment, process.platform, { fileCloseResources })
 				],
 				linuxDemoRuntimeCheck: () => inspectLinuxPrivateDisplay(environment)
 			});

package/dist/cli-runtime/{dotnet__ManagedStaticProvider-C8_yZCDc.js → dotnet__ManagedStaticProvider-DO5Yzcp4.js}

@@ -1,5 +1,5 @@
 import "./rolldown-runtime-DXoylpqc.js";
-import { ManagedStaticProvider, init_ManagedStaticProvider } from "./binary-BVOr2mgE.js";
+import { ManagedStaticProvider, init_ManagedStaticProvider } from "./binary-CWVNJhAC.js";
 
 init_ManagedStaticProvider();
 export { ManagedStaticProvider };

package/dist/cli-runtime/{errorSchemas-CTRmvMl3.js → errorSchemas-Ixz_q7qt.js}

@@ -3,7 +3,7 @@ import { z } from "zod";
 import { types } from "node:util";
 
 //#region dist/domain/analysisErrorBase.js
-var ANALYSIS_ERROR_TAGS, AnalysisError;
+var ANALYSIS_ERROR_TAGS, AnalysisError, resolvedAnalysisError;
 function init_analysisErrorBase() {
 	return (init_analysisErrorBase = __esmMin((() => {
 		ANALYSIS_ERROR_TAGS = [
@@ -36,25 +36,47 @@ function init_analysisErrorBase() {
 			"BinaryTargetError"
 		];
 		AnalysisError = class extends Error {
+			#cleanupPrimary;
+			#cleanupDependencies;
+			#cleanupDependents = [];
 			diagnostics;
 			capturedOutput;
 			cleanup;
 			cleanupIncomplete;
-			cleanupResources;
+			#ownedCleanupResources;
+			#cleanupResourceOwner;
 			constructor(message, options) {
 				super(message, options);
+				this.#cleanupPrimary = options?.cleanupPrimary;
 				this.diagnostics = options?.diagnostics === undefined ? undefined : structuredClone(options.diagnostics);
 				this.capturedOutput = options?.capturedOutput === undefined ? undefined : { ...options.capturedOutput };
 				this.cleanup = options?.cleanup;
 				this.cleanupIncomplete = options?.cleanup !== undefined;
-				this.cleanupResources = options?.cleanup?.resources ?? [];
+				this.#ownedCleanupResources = [...options?.cleanup?.resources ?? []];
 				this.partialObservation = options?.partialObservation;
 			}
 			userMessage = undefined;
 			userCategory = undefined;
 			executionFailure = undefined;
 			partialObservation;
+			get cleanupPrimary() {
+				return this.#cleanupPrimary;
+			}
 			cleanupReport = undefined;
+			/** Live dependencies own current resource attribution; cleanup keeps history. */
+			get cleanupResources() {
+				if (this.#cleanupDependencies === undefined) return this.#cleanupResourceOwner?.cleanupResources ?? this.#ownedCleanupResources;
+				return [...new Set([...this.#cleanupDependencies].filter((dependency) => dependency.cleanupIncomplete).flatMap((dependency) => dependency.cleanupResources))];
+			}
+			/** Bind attribution only to the producer that owns the complete cleanup set. */
+			bindCleanupResourceOwner(owner) {
+				this.#cleanupResourceOwner = owner;
+				return this;
+			}
+			/** Initialize resource facts supplied by a more specific error producer. */
+			setCleanupResources(resources) {
+				this.#ownedCleanupResources = [...resources];
+			}
 			/** Retain a later lifecycle failure without replacing the original typed error. */
 			retainSecondaryFailure(failure, diagnostics) {
 				Object.assign(this, {
@@ -66,9 +88,24 @@ function init_analysisErrorBase() {
 				});
 				return this;
 			}
+			/** Keep a composed error incomplete until all explicitly owned source errors resolve. */
+			bindCleanupDependencies(dependencies) {
+				const pending = this.#cleanupDependencies ??= new Set();
+				for (const dependency of dependencies) {
+					if (!dependency.cleanupIncomplete || pending.has(dependency)) continue;
+					pending.add(dependency);
+					dependency.#cleanupDependents = [...dependency.#cleanupDependents.filter((reference) => reference.deref() !== undefined), new WeakRef(this)];
+				}
+				if (pending.size === 0) this.resolveCleanup();
+				return this;
+			}
 			/** Clear live cleanup status only after its owning resource confirms retry success. */
 			resolveCleanup() {
+				if ([...this.#cleanupDependencies ?? []].some((dependency) => dependency.cleanupIncomplete)) return this;
+				this.#cleanupDependencies?.clear();
 				this.cleanupIncomplete = false;
+				for (const reference of this.#cleanupDependents) reference.deref()?.resolveCleanup();
+				this.#cleanupDependents = [];
 				return this;
 			}
 			/** Retain a completed observation when a later step fails. */
@@ -77,6 +114,10 @@ function init_analysisErrorBase() {
 				return this;
 			}
 		};
+		resolvedAnalysisError = (error) => {
+			while (!error.cleanupIncomplete && error.cleanupPrimary !== undefined) error = error.cleanupPrimary;
+			return error;
+		};
 	})))();
 }
 
@@ -115,6 +156,12 @@ function init_analysisErrorCore() {
 			reportedLimits;
 			_tag = "AnalysisResourceConstraintError";
 			remediationAction;
+			/**
+			* Whether retrying the same request can succeed. A caller-selected bound is
+			* deterministic for the same input, so it is not retryable even when its
+			* resource kind would otherwise be treated as admission capacity.
+			*/
+			retryable;
 			constructor(operation, resource, reason, reportedLimits, options) {
 				super(`Resource constraint during ${operation}: ${reason}`, options);
 				this.operation = operation;
@@ -122,6 +169,7 @@ function init_analysisErrorCore() {
 				this.reason = reason;
 				this.reportedLimits = reportedLimits;
 				this.remediationAction = options?.remediationAction;
+				this.retryable = options?.retryable;
 			}
 		};
 		AnalysisProtocolError = class extends AnalysisError {
@@ -161,6 +209,7 @@ function init_analysisErrorCore() {
 			reason;
 			_tag = "AnalysisCapabilityUnavailableError";
 			userMessage;
+			remediationAction;
 			/** Incomplete cleanup must settle before the operation can be retried. */
 			retryable;
 			constructor(providerId, operation, reason, options) {
@@ -169,6 +218,7 @@ function init_analysisErrorCore() {
 				this.operation = operation;
 				this.reason = reason;
 				this.userMessage = options?.userMessage;
+				this.remediationAction = options?.remediationAction;
 				this.retryable = options?.retryable === true && !this.cleanupIncomplete;
 			}
 		};
@@ -184,10 +234,14 @@ function init_analysisErrorCore() {
 			operation;
 			timeoutMs;
 			_tag = "AnalysisTimeoutError";
+			userMessage;
+			remediationAction;
 			constructor(operation, timeoutMs, options) {
 				super(`Analysis operation timed out after ${String(timeoutMs)}ms: ${operation}`, options);
 				this.operation = operation;
 				this.timeoutMs = timeoutMs;
+				this.userMessage = options?.userMessage;
+				this.remediationAction = options?.remediationAction;
 			}
 		};
 		AnalysisAccessDeniedError = class extends AnalysisError {
@@ -598,4 +652,4 @@ function init_errorSchemas() {
 }
 
 //#endregion
-export { ANALYSIS_RESOURCE_KINDS, AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisProtocolError, AnalysisResourceConstraintError, AnalysisTimeoutError, AnalysisUnsupportedTargetError, BinaryTargetError, ConfigurationError, MAX_JSON_DEPTH, NoBinaryOpenError, PROVIDER_FAILURE_STAGES, PROVIDER_OPERATION_STATES, PROVIDER_RETRY_ACTIONS, analysisCliErrorEnvelopeSchema, analysisErrorProjectionSchema, freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_analysisErrorBase, init_analysisErrorCore, init_configurationErrors, init_errorSchemas, init_immutableJson, init_jsonValue, init_providerOperationHealth, isImmutableJsonSnapshot, jsonObjectSchema, jsonValueSchema, jsonValueValidationIssue, jsonValueValidationSteps, providerRetryAction, sharedProviderFailureStage };
+export { ANALYSIS_RESOURCE_KINDS, AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisProtocolError, AnalysisResourceConstraintError, AnalysisTimeoutError, AnalysisUnsupportedTargetError, BinaryTargetError, ConfigurationError, MAX_JSON_DEPTH, NoBinaryOpenError, PROVIDER_FAILURE_STAGES, PROVIDER_OPERATION_STATES, PROVIDER_RETRY_ACTIONS, analysisCliErrorEnvelopeSchema, analysisErrorProjectionSchema, freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_analysisErrorBase, init_analysisErrorCore, init_configurationErrors, init_errorSchemas, init_immutableJson, init_jsonValue, init_providerOperationHealth, isImmutableJsonSnapshot, jsonObjectSchema, jsonValueSchema, jsonValueValidationIssue, jsonValueValidationSteps, providerRetryAction, resolvedAnalysisError, sharedProviderFailureStage };

package/dist/cli-runtime/homeDirectory-DC_DeJIg.js

@@ -0,0 +1,18 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { userInfo } from "node:os";
+
+//#region dist/config/homeDirectory.js
+var firstNonempty, homeDirectoryFromEnvironment;
+function init_homeDirectory() {
+	return (init_homeDirectory = __esmMin((() => {
+		firstNonempty = (...values) => values.find((value) => value !== undefined && value.length > 0);
+		homeDirectoryFromEnvironment = (environment, platform) => {
+			const windowsDriveHome = environment.HOMEDRIVE !== undefined && environment.HOMEDRIVE.length > 0 && environment.HOMEPATH !== undefined && environment.HOMEPATH.length > 0 ? `${environment.HOMEDRIVE}${environment.HOMEPATH}` : undefined;
+			const selected = platform === "win32" ? firstNonempty(environment.USERPROFILE, windowsDriveHome, environment.HOME) : firstNonempty(environment.HOME, environment.USERPROFILE);
+			return selected ?? userInfo().homedir;
+		};
+	})))();
+}
+
+//#endregion
+export { homeDirectoryFromEnvironment, init_homeDirectory };