@pact-toolbox/unplugin/dist/utils-DOhsgEZO.cjs

const require_chunk = require('./chunk-CUT6urMc.cjs');
const __pact_toolbox_config = require_chunk.__toESM(require("@pact-toolbox/config"));
const __pact_toolbox_network = require_chunk.__toESM(require("@pact-toolbox/network"));
const __pact_toolbox_runtime = require_chunk.__toESM(require("@pact-toolbox/runtime"));
const __pact_toolbox_utils = require_chunk.__toESM(require("@pact-toolbox/utils"));

//#region src/plugin/utils.ts
const RUNNING_NETWORKS_KEY = Symbol.for("__PACT_TOOLBOX_RUNNING_NETWORKS__");
function getRunningNetworksRegistry() {
	if (!globalThis[RUNNING_NETWORKS_KEY]) globalThis[RUNNING_NETWORKS_KEY] = /* @__PURE__ */ new Map();
	return globalThis[RUNNING_NETWORKS_KEY];
}
async function isNetworkRunning(networkConfig) {
	const registry = getRunningNetworksRegistry();
	const registryKey = `${networkConfig.name || "unknown"}-${networkConfig.type}`;
	const registeredNetwork = registry.get(registryKey);
	if (registeredNetwork) {
		const portInUse = await (0, __pact_toolbox_utils.isPortTaken)(registeredNetwork.port);
		if (portInUse) return true;
		else {
			registry.delete(registryKey);
			return false;
		}
	}
	try {
		const port = (0, __pact_toolbox_config.getNetworkPort)(networkConfig);
		return await (0, __pact_toolbox_utils.isPortTaken)(port);
	} catch {
		return false;
	}
}
function registerRunningNetwork(networkConfig, client, network) {
	const registry = getRunningNetworksRegistry();
	const registryKey = `${networkConfig.name || "unknown"}-${networkConfig.type}`;
	const port = (0, __pact_toolbox_config.getNetworkPort)(networkConfig);
	registry.set(registryKey, {
		networkName: networkConfig.name || "unknown",
		port,
		startTime: Date.now(),
		client,
		network
	});
}
async function createPactToolboxNetwork({ isServe, isTest, client, networkConfig }, toolboxConfig, { startNetwork = true, onReady } = {}) {
	if (!isServe || isTest || !(0, __pact_toolbox_config.isLocalNetwork)(networkConfig) || !startNetwork) {
		if (isServe && !isTest && onReady) await onReady(client);
		return {
			network: null,
			client
		};
	}
	const isRunning = await isNetworkRunning(networkConfig);
	if (isRunning) {
		if (onReady) await onReady(client);
		return {
			network: null,
			client
		};
	}
	let network;
	try {
		network = await (0, __pact_toolbox_network.createPactToolboxNetwork)(toolboxConfig, {
			client,
			logAccounts: true,
			conflictStrategy: "ignore",
			isDetached: true,
			autoStart: startNetwork,
			cleanup: true
		});
		registerRunningNetwork(networkConfig, client, network);
	} catch (error) {
		if (error instanceof Error && error.message.includes("already running")) registerRunningNetwork(networkConfig, client, null);
		else {
			__pact_toolbox_utils.logger.error(`[startToolboxNetwork] Failed to start network ${networkConfig.name}:`, error);
			throw error;
		}
	}
	if (onReady) try {
		await onReady(client);
	} catch (error) {
		__pact_toolbox_utils.logger.error(`[startToolboxNetwork] onReady callback failed for ${networkConfig.name}:`, error);
	}
	return {
		network,
		client
	};
}
const PLUGIN_NAME = "pact-toolbox";
function isAggregateError(e) {
	return e instanceof AggregateError;
}
function prettyPrintError(label, error) {
	console.error(`\n\x1b[31m[${label}]\x1b[0m`);
	if (isAggregateError(error)) {
		console.error("\x1B[31mMultiple errors occurred:\x1B[0m");
		error.errors.forEach((err, index) => {
			console.error(`\x1b[31m[${index + 1}]\x1b[0m ${err instanceof Error ? err.message : String(err)}`);
			if (err instanceof Error && err.stack) console.error(`\x1b[90m${err.stack.split("\n").slice(1).join("\n")}\x1b[0m`);
		});
	} else if (error instanceof Error) {
		console.error(`\x1b[31m${error.message}\x1b[0m`);
		if (error.stack) console.error(`\x1b[90m${error.stack.split("\n").slice(1).join("\n")}\x1b[0m`);
	} else console.error(`\x1b[31m${String(error)}\x1b[0m`);
}

//#endregion
Object.defineProperty(exports, 'PLUGIN_NAME', {
  enumerable: true,
  get: function () {
    return PLUGIN_NAME;
  }
});
Object.defineProperty(exports, 'createPactToolboxNetwork', {
  enumerable: true,
  get: function () {
    return createPactToolboxNetwork;
  }
});
Object.defineProperty(exports, 'isAggregateError', {
  enumerable: true,
  get: function () {
    return isAggregateError;
  }
});
Object.defineProperty(exports, 'prettyPrintError', {
  enumerable: true,
  get: function () {
    return prettyPrintError;
  }
});