reverseport 0.0.0-stage → 1.0.0

package/dist/cli-runtime/application__UpdateRuntime-Dj6UIhHQ.js

@@ -0,0 +1,358 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { PRODUCT_IDENTITY, err, init_identity, init_result, ok } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { init_safeJson, safeParseJson } from "./safeJson-DKKACtdy.js";
+import { homeDirectoryFromEnvironment, init_ClientRegistrationIdentity, init_SupportedClients, init_homeDirectory, isOwnedClientRegistrationCommand, supportedClients, withoutPackageRunnerIdentity } from "./SupportedClients-BrZ2qZVg.js";
+import { init_RegularFileRead, readRegularFileText } from "./RegularFileRead-BMh5FMXd.js";
+import { ArtifactResourceScope, init_ArtifactResourceScope } from "./ArtifactResourceScope-CZqLEfbb.js";
+import { clientServerForcedEnabled, clientServerListedDisabled, effectiveClientServer, existingSkillDestinations, init_ClientConfigurationDocument, init_SetupSkill, parseClientConfiguration } from "./ClientConfigurationDocument-D0ZqgTCv.js";
+import { init_ClientRegistrationStatus, readClientRegistrationStatuses } from "./ClientRegistrationStatus-DGpwJ4ry.js";
+import { init_Update, updateInstallCommand } from "./Update-DF55X_N2.js";
+import { basename, dirname, join, resolve } from "node:path";
+import { z } from "zod";
+import { realpath, stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { lt, valid } from "semver";
+import spawn from "cross-spawn";
+
+//#region dist/application/UpdateMaintenance.js
+var setupPlanSchema, existingMaintenanceScope, planIntegrationMaintenance;
+function init_UpdateMaintenance() {
+	return (init_UpdateMaintenance = __esmMin((() => {
+		init_identity();
+		init_ClientRegistrationIdentity();
+		init_ClientRegistrationStatus();
+		init_ClientConfigurationDocument();
+		init_SupportedClients();
+		init_SetupSkill();
+		init_RegularFileRead();
+		setupPlanSchema = z.object({
+			status: z.literal("planned"),
+			plannedActions: z.array(z.object({
+				id: z.string(),
+				kind: z.enum(["configure_client", "install_skill"]),
+				label: z.string(),
+				target: z.string(),
+				detail: z.string(),
+				external: z.literal(false),
+				operation: z.enum([
+					"create",
+					"update",
+					"install"
+				]),
+				backupPath: z.string().optional(),
+				commands: z.array(z.string()).optional()
+			}))
+		});
+		existingMaintenanceScope = async (home, entryPoint, environment, resources) => {
+			const registrations = await readClientRegistrationStatuses(home, entryPoint, {
+				environment,
+				...resources === undefined ? {} : { resources }
+			});
+			const supported = supportedClients(home, process.platform, environment);
+			const clients = [];
+			for (const registration of registrations) {
+				if (registration.state !== "aligned" && registration.state !== "stale" || !isOwnedClientRegistrationCommand(registration.command, entryPoint)) continue;
+				const client = supported.find(({ name }) => name === registration.client);
+				if (client === undefined) continue;
+				const parsed = parseClientConfiguration(await readRegularFileText(client.configPath, resources === undefined ? {} : { resources }), client.format);
+				const enabled = z.object({
+					enabled: z.boolean().optional(),
+					disabled: z.boolean().optional()
+				}).parse(effectiveClientServer(parsed, PRODUCT_IDENTITY.mcpServerKey));
+				if ((enabled.enabled !== false || clientServerForcedEnabled(parsed, PRODUCT_IDENTITY.mcpServerKey)) && enabled.disabled !== true && !clientServerListedDisabled(parsed, PRODUCT_IDENTITY.mcpServerKey)) clients.push(client.name);
+			}
+			const skillDestinations = await existingSkillDestinations(home, environment, process.platform, resources);
+			return {
+				clients,
+				skill: skillDestinations.length > 0,
+				skillDestinations
+			};
+		};
+		planIntegrationMaintenance = async (home, entryPoint, environment, execute, resources) => {
+			try {
+				const scope = await existingMaintenanceScope(home, entryPoint, environment, resources);
+				const skillDestinations = scope.skillDestinations ?? [];
+				if (scope.clients.length === 0 && !scope.skill) return {
+					status: "current",
+					plannedActions: []
+				};
+				const command = [
+					process.execPath,
+					entryPoint,
+					"setup",
+					...scope.clients.flatMap((client) => ["--client", client]),
+					...skillDestinations.flatMap(({ client }) => ["--skill-client", client]),
+					`--skill=${String(scope.skill)}`
+				];
+				const execution = await execute([
+					...command,
+					"--dry-run",
+					"--json"
+				]);
+				if (!execution.ok) return {
+					status: "unavailable",
+					remediation: execution.error
+				};
+				const plan = setupPlanSchema.safeParse(JSON.parse(execution.value));
+				if (!plan.success) return {
+					status: "unavailable",
+					remediation: `The updated setup executable returned an invalid maintenance plan: ${plan.error.message}`
+				};
+				if (plan.data.plannedActions.length === 0) return {
+					status: "current",
+					plannedActions: []
+				};
+				const allowedIds = new Set(scope.clients.map((client) => `configure_client:${client}`));
+				const skillTargets = new Set(skillDestinations.map(({ path }) => path));
+				if (plan.data.plannedActions.some((action) => action.kind === "install_skill" ? !skillTargets.has(action.target) : !allowedIds.has(action.id))) return {
+					status: "unavailable",
+					remediation: "The updated setup plan included an integration outside the existing REA maintenance scope."
+				};
+				return {
+					status: "planned",
+					scope,
+					command,
+					plannedActions: plan.data.plannedActions.map(({ backupPath, commands, ...action }) => ({
+						...action,
+						...backupPath === undefined ? {} : { backupPath },
+						...commands === undefined ? {} : { commands }
+					}))
+				};
+			} catch (cause) {
+				return {
+					status: "unavailable",
+					remediation: cause instanceof Error ? cause.message : String(cause)
+				};
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/UpdateRuntime.js
+var runUpdateCommand, requireCommandOutput, detectNpmInstallation, nonemptyEnvironment, bunGlobalDirectory, detectBunInstallation, INVALID_NPM_RELEASE_METADATA, BUN_LATEST_VERSION_COMMAND, npmLatestVersionCommand, parseNpmLatestVersion, readNpmLatestVersion, nonemptyVersion, npmReleaseLookup, isFile, packageManagerContext, systemUpdateHost;
+function init_UpdateRuntime() {
+	return (init_UpdateRuntime = __esmMin((() => {
+		init_homeDirectory();
+		init_identity();
+		init_ArtifactResourceScope();
+		init_result();
+		init_safeJson();
+		init_Update();
+		init_UpdateMaintenance();
+		init_ClientRegistrationIdentity();
+		runUpdateCommand = (command, selectedEnvironment, output = "structured", workingDirectory = undefined) => new Promise((resolveResult) => {
+			const [executable, ...args] = command;
+			if (executable === undefined) {
+				resolveResult(err("No executable supplied."));
+				return;
+			}
+			const environment = withoutPackageRunnerIdentity(selectedEnvironment);
+			const child = spawn(executable, args, {
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				env: environment,
+				windowsHide: true,
+				...workingDirectory === undefined ? {} : { cwd: workingDirectory }
+			});
+			let stdout = "";
+			let stderr = "";
+			child.stdout?.setEncoding("utf8");
+			child.stderr?.setEncoding("utf8");
+			child.stdout?.on("data", (chunk) => {
+				stdout += chunk;
+				if (output === "human") process.stderr.write(chunk);
+			});
+			child.stderr?.on("data", (chunk) => {
+				stderr += chunk;
+				if (output === "human") process.stderr.write(chunk);
+			});
+			child.once("error", (cause) => resolveResult(err(cause.message)));
+			child.once("close", (code, signal) => resolveResult(code === 0 ? ok(stdout.trim()) : err(stderr.trim() || stdout.trim() || (signal === null ? `Process exited with code ${String(code)}.` : `Process terminated by ${signal}.`))));
+		});
+		requireCommandOutput = async (command, environment) => {
+			const result = await runUpdateCommand(command, environment);
+			if (!result.ok) throw new Error(result.error);
+			return result.value;
+		};
+		detectNpmInstallation = async (packageRoot, host) => {
+			let canonicalPackageRoot;
+			try {
+				canonicalPackageRoot = await host.canonicalPath(packageRoot);
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+			try {
+				const npmRoot = await host.globalRoot();
+				const globalPackageRoot = await host.canonicalPath(resolve(npmRoot, PRODUCT_IDENTITY.packageName));
+				if (canonicalPackageRoot === globalPackageRoot) {
+					const prefix = await host.globalPrefix();
+					return prefix.length === 0 ? undefined : {
+						manager: "npm",
+						prefix,
+						packageRoot: canonicalPackageRoot
+					};
+				}
+			} catch (cause) {
+				void cause;
+			}
+			const nodeModules = dirname(canonicalPackageRoot);
+			const library = dirname(nodeModules);
+			if (basename(canonicalPackageRoot) !== PRODUCT_IDENTITY.packageName || basename(nodeModules) !== "node_modules" || basename(library) !== "lib") return undefined;
+			return {
+				manager: "npm",
+				prefix: dirname(library),
+				packageRoot: canonicalPackageRoot
+			};
+		};
+		nonemptyEnvironment = (value) => value === undefined || value.length === 0 ? undefined : value;
+		bunGlobalDirectory = (environment, platform) => {
+			const explicit = nonemptyEnvironment(environment.BUN_INSTALL_GLOBAL_DIR);
+			if (explicit !== undefined) return resolve(explicit);
+			const installRoot = nonemptyEnvironment(environment.BUN_INSTALL);
+			if (installRoot !== undefined) return resolve(installRoot, "install", "global");
+			const cacheRoot = nonemptyEnvironment(environment.XDG_CACHE_HOME) ?? homeDirectoryFromEnvironment(environment, platform);
+			return resolve(cacheRoot, ".bun", "install", "global");
+		};
+		detectBunInstallation = async (packageRoot, globalDirectory, host) => {
+			try {
+				const canonicalPackageRoot = await host.canonicalPath(packageRoot);
+				const globalPackageRoot = await host.canonicalPath(join(globalDirectory, "node_modules", PRODUCT_IDENTITY.packageName));
+				if (canonicalPackageRoot !== globalPackageRoot || !await host.isFile(join(globalDirectory, "package.json"))) return undefined;
+				return {
+					manager: "bun",
+					globalDirectory,
+					packageRoot: canonicalPackageRoot
+				};
+			} catch (cause) {
+				void cause;
+				return undefined;
+			}
+		};
+		INVALID_NPM_RELEASE_METADATA = "Invalid npm release metadata: expected a version string or a single-element version array.";
+		BUN_LATEST_VERSION_COMMAND = [
+			"bun",
+			"info",
+			PRODUCT_IDENTITY.packageName,
+			"dist-tags.latest",
+			"--json"
+		];
+		npmLatestVersionCommand = (installation) => [
+			"npm",
+			"view",
+			"--global",
+			...installation === undefined ? [] : ["--prefix", installation.prefix],
+			PRODUCT_IDENTITY.packageName,
+			"dist-tags.latest",
+			"--json",
+			"--fetch-retries=0",
+			"--fetch-timeout=10000"
+		];
+		parseNpmLatestVersion = (metadata) => {
+			const decoded = safeParseJson(metadata);
+			if (!decoded.ok) return err(decoded.error);
+			const version = readNpmLatestVersion(decoded.value);
+			return version === undefined ? err(INVALID_NPM_RELEASE_METADATA) : ok(version);
+		};
+		readNpmLatestVersion = (value) => {
+			if (typeof value === "string") return nonemptyVersion(value);
+			if (!Array.isArray(value) || value.length !== 1) return undefined;
+			const only = value[0];
+			return typeof only === "string" ? nonemptyVersion(only) : undefined;
+		};
+		nonemptyVersion = (value) => value.length === 0 ? undefined : value;
+		npmReleaseLookup = (response) => {
+			if (!response.ok) return err({
+				kind: "unavailable",
+				detail: response.error
+			});
+			const parsed = parseNpmLatestVersion(response.value);
+			return parsed.ok ? ok(parsed.value) : err({
+				kind: "invalid-metadata",
+				detail: parsed.error
+			});
+		};
+		isFile = async (path) => {
+			try {
+				return (await stat(path)).isFile();
+			} catch (cause) {
+				void cause;
+				return false;
+			}
+		};
+		packageManagerContext = (installation, environment) => installation?.manager === "bun" ? {
+			environment: {
+				...environment,
+				BUN_INSTALL_GLOBAL_DIR: installation.globalDirectory
+			},
+			workingDirectory: installation.globalDirectory
+		} : {
+			environment,
+			workingDirectory: undefined
+		};
+		systemUpdateHost = (packageRoot = fileURLToPath(new URL("../..", new URL("../application/UpdateRuntime.js", import.meta.url).href)), home = undefined, environment = process.env) => {
+			const resources = new ArtifactResourceScope();
+			return {
+				installation: async () => await detectBunInstallation(packageRoot, bunGlobalDirectory(environment, process.platform), {
+					canonicalPath: realpath,
+					isFile
+				}) ?? detectNpmInstallation(packageRoot, {
+					canonicalPath: realpath,
+					globalRoot: () => requireCommandOutput([
+						"npm",
+						"root",
+						"--global"
+					], environment),
+					globalPrefix: () => requireCommandOutput([
+						"npm",
+						"prefix",
+						"--global"
+					], environment)
+				}),
+				latestVersion: async (installation) => {
+					const context = packageManagerContext(installation, environment);
+					if (installation?.manager === "bun") {
+						const version = await runUpdateCommand(["bun", "--version"], context.environment, "structured", context.workingDirectory);
+						if (!version.ok) return err({
+							kind: "unavailable",
+							detail: version.error
+						});
+						const bunVersion = valid(version.value);
+						if (bunVersion === null || lt(bunVersion, "1.2.17")) return err({
+							kind: "unsupported-package-manager",
+							detail: `REA updates for Bun global installations require Bun 1.2.17 or later; bun --version returned ${JSON.stringify(version.value)}. Upgrade Bun manually, then rerun reverseport update.`
+						});
+					}
+					return npmReleaseLookup(await runUpdateCommand(installation?.manager === "bun" ? BUN_LATEST_VERSION_COMMAND : npmLatestVersionCommand(installation), context.environment, "structured", context.workingDirectory));
+				},
+				installVersion: async (installation, version, output) => {
+					const context = packageManagerContext(installation, environment);
+					const result = await runUpdateCommand(updateInstallCommand(installation, version), context.environment, output, context.workingDirectory);
+					return result.ok ? ok(undefined) : result;
+				},
+				installedVersion: (installation) => runUpdateCommand([
+					process.execPath,
+					join(installation.packageRoot, "scripts", "rea.mjs"),
+					"--version"
+				], environment),
+				planMaintenance: (installation) => planIntegrationMaintenance(home ?? homeDirectoryFromEnvironment(environment, process.platform), join(installation.packageRoot, "scripts", "rea.mjs"), environment, (command) => runUpdateCommand(command, environment), resources),
+				close: async () => {
+					try {
+						await resources.close();
+						return undefined;
+					} catch (cause) {
+						return `Update resource cleanup failed: ${cause instanceof Error ? cause.message : String(cause)}`;
+					}
+				}
+			};
+		};
+	})))();
+}
+
+//#endregion
+init_UpdateRuntime();
+export { BUN_LATEST_VERSION_COMMAND, bunGlobalDirectory, detectBunInstallation, detectNpmInstallation, npmLatestVersionCommand, npmReleaseLookup, parseNpmLatestVersion, runUpdateCommand, systemUpdateHost };

package/dist/cli-runtime/application__android__AndroidApplicationService-CyynwW6Z.js

@@ -0,0 +1,31 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { androidApplicationProjectionInputSchema, init_androidApplication, projectAndroidApplication } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { ANDROID_APPLICATION_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-D-QCy-4c.js";
+import { init_InventoryProjectionEvidence, projectInventoryEvidence } from "./InventoryProjectionEvidence-Dt4Og45O.js";
+
+//#region dist/application/android/AndroidApplicationService.js
+var OPERATION, projectAndroidApplicationEvidence;
+function init_AndroidApplicationService() {
+	return (init_AndroidApplicationService = __esmMin((() => {
+		init_androidApplication();
+		init_InvestigationProviders();
+		init_InventoryProjectionEvidence();
+		OPERATION = "project_android_application_graph";
+		projectAndroidApplicationEvidence = (rawInput) => {
+			return projectInventoryEvidence({
+				rawInput,
+				schema: androidApplicationProjectionInputSchema,
+				project: projectAndroidApplication,
+				operation: OPERATION,
+				predicateType: "rea.android-application-graph",
+				provider: ANDROID_APPLICATION_PROVIDER,
+				subjectFormat: () => "apk",
+				protocolError: "Android application projection produced an invalid result"
+			});
+		};
+	})))();
+}
+
+//#endregion
+init_AndroidApplicationService();
+export { projectAndroidApplicationEvidence };

package/dist/cli-runtime/application__apple__AppleApplicationService-BNPcWeL8.js

@@ -0,0 +1,31 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { appleApplicationProjectionInputSchema, init_appleApplication, projectAppleApplication } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { APPLE_APPLICATION_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-D-QCy-4c.js";
+import { init_InventoryProjectionEvidence, projectInventoryEvidence } from "./InventoryProjectionEvidence-Dt4Og45O.js";
+
+//#region dist/application/apple/AppleApplicationService.js
+var OPERATION, projectAppleApplicationEvidence;
+function init_AppleApplicationService() {
+	return (init_AppleApplicationService = __esmMin((() => {
+		init_appleApplication();
+		init_InvestigationProviders();
+		init_InventoryProjectionEvidence();
+		OPERATION = "project_apple_application_graph";
+		projectAppleApplicationEvidence = (rawInput) => {
+			return projectInventoryEvidence({
+				rawInput,
+				schema: appleApplicationProjectionInputSchema,
+				project: projectAppleApplication,
+				operation: OPERATION,
+				predicateType: "rea.apple-application-graph",
+				provider: APPLE_APPLICATION_PROVIDER,
+				subjectFormat: (first) => first.subject?.format ?? "unknown",
+				protocolError: "Apple application projection produced an invalid result"
+			});
+		};
+	})))();
+}
+
+//#endregion
+init_AppleApplicationService();
+export { projectAppleApplicationEvidence };

package/dist/cli-runtime/application__harmony__HarmonyApplicationService-W66PwMvx.js

@@ -0,0 +1,31 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { harmonyApplicationProjectionInputSchema, init_harmonyApplication, projectHarmonyApplication } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { HARMONY_APPLICATION_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-D-QCy-4c.js";
+import { init_InventoryProjectionEvidence, projectInventoryEvidence } from "./InventoryProjectionEvidence-Dt4Og45O.js";
+
+//#region dist/application/harmony/HarmonyApplicationService.js
+var OPERATION, projectHarmonyApplicationEvidence;
+function init_HarmonyApplicationService() {
+	return (init_HarmonyApplicationService = __esmMin((() => {
+		init_harmonyApplication();
+		init_InvestigationProviders();
+		init_InventoryProjectionEvidence();
+		OPERATION = "project_harmony_application_graph";
+		projectHarmonyApplicationEvidence = (rawInput) => {
+			return projectInventoryEvidence({
+				rawInput,
+				schema: harmonyApplicationProjectionInputSchema,
+				project: projectHarmonyApplication,
+				operation: OPERATION,
+				predicateType: "rea.harmony-application-graph",
+				provider: HARMONY_APPLICATION_PROVIDER,
+				subjectFormat: (first) => first.subject?.format ?? "unknown",
+				protocolError: "HarmonyOS application projection produced an invalid result"
+			});
+		};
+	})))();
+}
+
+//#endregion
+init_HarmonyApplicationService();
+export { projectHarmonyApplicationEvidence };

package/dist/cli-runtime/application__javascript__ElectronActiveObservationService-D8VbeCxz.js

@@ -0,0 +1,85 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, init_analysisErrorCore, init_jsonValue, jsonObjectSchema, jsonValueSchema } from "./providerOperationHealth-DSTcYPJe.js";
+import { createEvidence, digestCanonicalValue, err, init_canonicalDigest, init_evidence, init_result } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+import { dirname } from "node:path";
+import { realpath } from "node:fs/promises";
+
+//#region dist/application/javascript/ElectronActiveEvidence.js
+var createElectronActiveEvidence, parameters;
+function init_ElectronActiveEvidence() {
+	return (init_ElectronActiveEvidence = __esmMin((() => {
+		init_canonicalDigest();
+		init_evidence();
+		init_jsonValue();
+		createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
+			predicateType: "rea.electron-active-scenario",
+			operation: "capture_electron_scenario",
+			parameters: parameters(input),
+			result: jsonValueSchema.parse(result),
+			confidence: "observed",
+			authority: "controlled-replay",
+			environment: {
+				id: `${result.application.electron_version}@unknown`,
+				platform: "unknown",
+				architecture: "unknown",
+				isolation: "none"
+			},
+			limitations: [...result.limitations, "Application host platform and architecture were not observed."]
+		});
+		parameters = (input) => {
+			const scenario = jsonObjectSchema.parse(input);
+			return {
+				...scenario,
+				scenario_sha256: digestCanonicalValue(scenario, "Electron scenario")
+			};
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/application/javascript/ElectronActiveObservationService.js
+var OPERATION, PROVIDER_ID, canonicalizeInput, captureElectronScenario;
+function init_ElectronActiveObservationService() {
+	return (init_ElectronActiveObservationService = __esmMin((() => {
+		init_analysisErrorCore();
+		init_result();
+		init_ElectronActiveEvidence();
+		OPERATION = "capture_electron_scenario";
+		PROVIDER_ID = "rea-playwright-electron-active";
+		canonicalizeInput = async (input) => {
+			try {
+				const [executablePath, applicationPath] = await Promise.all([realpath(input.executable_path), realpath(input.application_path)]);
+				const applicationRoot = input.application_root === undefined ? dirname(applicationPath) : await realpath(input.application_root);
+				return {
+					ok: true,
+					value: {
+						...input,
+						executable_path: executablePath,
+						application_path: applicationPath,
+						application_root: applicationRoot
+					}
+				};
+			} catch (cause) {
+				return err(new AnalysisInputError(OPERATION, { cause }, [{
+					path: ["application_path"],
+					reason: "invalid_format",
+					message: "Electron executable, application, and root must resolve to existing paths"
+				}]));
+			}
+		};
+		captureElectronScenario = async (provider, input, options = {}) => {
+			const canonical = await canonicalizeInput(input);
+			if (!canonical.ok) return canonical;
+			if (provider === undefined) return err(new AnalysisCapabilityUnavailableError(PROVIDER_ID, OPERATION, "active Electron observation provider is not configured"));
+			const captured = await provider.capture(canonical.value, options);
+			return captured.ok ? {
+				ok: true,
+				value: createElectronActiveEvidence(canonical.value, captured.value, provider.identity())
+			} : captured;
+		};
+	})))();
+}
+
+//#endregion
+init_ElectronActiveObservationService();
+export { captureElectronScenario };

package/dist/cli-runtime/application__javascript__ElectronObservationService-FmXFG4f2.js

@@ -0,0 +1,63 @@
+import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
+import { AnalysisCapabilityUnavailableError, init_analysisErrorCore, init_jsonValue, jsonValueSchema } from "./providerOperationHealth-DSTcYPJe.js";
+import { createEvidence, err, init_evidence, init_result, ok } from "./reconstructionObligationLedgerSchemas-dvp6PEnZ.js";
+
+//#region dist/application/javascript/ElectronEvidence.js
+var createElectronEvidence, parameters;
+function init_ElectronEvidence() {
+	return (init_ElectronEvidence = __esmMin((() => {
+		init_evidence();
+		init_jsonValue();
+		createElectronEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
+			predicateType: operation === "list_electron_targets" ? "rea.electron-target-list" : "rea.electron-page-inspection",
+			operation,
+			parameters: parameters(input),
+			result: jsonValueSchema.parse(result),
+			confidence: "observed",
+			authority: "external-service",
+			environment: "target" in result ? {
+				id: `${result.browser.product}@${result.browser.revision}`,
+				platform: "unknown",
+				architecture: "unknown",
+				isolation: "none"
+			} : null,
+			limitations: [...result.limitations, ..."target" in result ? ["Browser host platform and architecture were not observed."] : []]
+		});
+		parameters = (input) => ({
+			cdp_endpoint: input.cdp_endpoint,
+			..."target_id" in input ? {
+				target_id: input.target_id,
+				observation_ms: input.observation_ms,
+				include_script_sources: input.include_script_sources
+			} : {}
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/application/javascript/ElectronObservationService.js
+var listElectronTargets, inspectElectronPage, requireProvider;
+function init_ElectronObservationService() {
+	return (init_ElectronObservationService = __esmMin((() => {
+		init_analysisErrorCore();
+		init_result();
+		init_ElectronEvidence();
+		listElectronTargets = async (provider, input, options = {}) => {
+			const ready = requireProvider(provider, "list_electron_targets");
+			if (!ready.ok) return ready;
+			const result = await ready.value.listTargets(input, options);
+			return result.ok ? ok(createElectronEvidence("list_electron_targets", input, result.value, ready.value.identity())) : result;
+		};
+		inspectElectronPage = async (provider, input, options = {}) => {
+			const ready = requireProvider(provider, "inspect_electron_page");
+			if (!ready.ok) return ready;
+			const result = await ready.value.inspectPage(input, options);
+			return result.ok ? ok(createElectronEvidence("inspect_electron_page", input, result.value, ready.value.identity())) : result;
+		};
+		requireProvider = (provider, operation) => provider === undefined ? err(new AnalysisCapabilityUnavailableError("rea-cdp-electron", operation, "Electron observation provider is not configured")) : ok(provider);
+	})))();
+}
+
+//#endregion
+init_ElectronObservationService();
+export { inspectElectronPage, listElectronTargets };