ns-auth-sdk 1.14.0 → 1.14.2

package/dist/peer-XrPL0O6z.cjs

@@ -1,822 +0,0 @@
-const require_types = require('./types-B-TLIS13.cjs');
-const require_keyset = require('./keyset-Cxdgu110.cjs');
-const require_ping = require('./ping-BtVhKocl.cjs');
-
-//#region node_modules/@frostr/igloo-core/dist/peer.js
-/**
-* Utility functions for pubkey handling
-*/
-/**
-* Normalize a pubkey by removing 02/03 prefix if present
-*/
-function normalizePubkey(pubkey) {
-	if (!pubkey || typeof pubkey !== "string") return pubkey;
-	if ((pubkey.startsWith("02") || pubkey.startsWith("03")) && pubkey.length === 66) return pubkey.slice(2);
-	return pubkey;
-}
-/**
-* Add 02 prefix to a pubkey if it's missing (convert to compressed format)
-*/
-function addPubkeyPrefix(pubkey, prefix = "02") {
-	if (!pubkey || typeof pubkey !== "string") return pubkey;
-	if ((pubkey.startsWith("02") || pubkey.startsWith("03")) && pubkey.length === 66) return pubkey;
-	if (pubkey.length === 64) return prefix + pubkey;
-	return pubkey;
-}
-/**
-* Compare two pubkeys after normalization
-*/
-function comparePubkeys(pubkey1, pubkey2) {
-	return normalizePubkey(pubkey1) === normalizePubkey(pubkey2);
-}
-/**
-* Extract self pubkey from credentials with enhanced error handling
-*/
-function extractSelfPubkeyFromCredentials(groupCredential, shareCredential, options = {}) {
-	const warnings = [];
-	const { normalize = true, suppressWarnings = false } = options;
-	try {
-		if (!shareCredential || !groupCredential) {
-			const warning = "Missing credentials for self pubkey extraction";
-			if (!suppressWarnings) warnings.push(warning);
-			return {
-				pubkey: null,
-				warnings
-			};
-		}
-		const decodedShare = require_keyset.decodeShare(shareCredential);
-		const decodedGroup = require_keyset.decodeGroup(groupCredential);
-		if (!decodedShare?.idx || !decodedGroup?.commits) {
-			const warning = "Invalid credential structure for self pubkey extraction";
-			if (!suppressWarnings) warnings.push(warning);
-			return {
-				pubkey: null,
-				warnings
-			};
-		}
-		const shareIndex = decodedShare.idx - 1;
-		if (shareIndex < 0 || shareIndex >= decodedGroup.commits.length) {
-			const warning = "Share index out of range for self pubkey extraction";
-			if (!suppressWarnings) warnings.push(warning);
-			return {
-				pubkey: null,
-				warnings
-			};
-		}
-		const selfPubkeyCommit = decodedGroup.commits[shareIndex];
-		const selfPubkey = typeof selfPubkeyCommit === "string" ? selfPubkeyCommit : selfPubkeyCommit.pubkey;
-		if (!selfPubkey) {
-			const warning = "Could not extract self public key from credentials";
-			if (!suppressWarnings) warnings.push(warning);
-			return {
-				pubkey: null,
-				warnings
-			};
-		}
-		return {
-			pubkey: normalize ? normalizePubkey(selfPubkey) : selfPubkey,
-			warnings
-		};
-	} catch (error) {
-		const warning = `Failed to extract self pubkey: ${error instanceof Error ? error.message : "Unknown error"}`;
-		if (!suppressWarnings) warnings.push(warning);
-		return {
-			pubkey: null,
-			warnings
-		};
-	}
-}
-/**
-* Default peer monitoring configuration
-*/
-const DEFAULT_PEER_MONITOR_CONFIG = {
-	pingInterval: require_ping.DEFAULT_PING_INTERVAL,
-	pingTimeout: require_ping.DEFAULT_PING_TIMEOUT,
-	autoMonitor: true,
-	enableLogging: false,
-	suppressWarnings: false,
-	onPeerStatusChange: void 0
-};
-/**
-* Static peer manager for fallback scenarios when live monitoring fails
-*/
-var StaticPeerManager = class {
-	constructor(peerPubkeys, warnings = [], config = {}) {
-		this.peers = peerPubkeys.map((pubkey) => ({
-			pubkey: normalizePubkey(pubkey),
-			status: "unknown",
-			lastSeen: void 0,
-			allowSend: true,
-			allowReceive: true
-		}));
-		this.warnings = warnings;
-		this.config = {
-			...DEFAULT_PEER_MONITOR_CONFIG,
-			...config
-		};
-	}
-	getPeerStatus() {
-		return {
-			peers: this.peers,
-			onlinePeers: [],
-			offlinePeers: this.peers,
-			totalPeers: this.peers.length,
-			onlineCount: 0,
-			lastChecked: /* @__PURE__ */ new Date()
-		};
-	}
-	getAllPeers() {
-		return [...this.peers];
-	}
-	getOnlinePeers() {
-		return [];
-	}
-	getOfflinePeers() {
-		return [...this.peers];
-	}
-	getOnlineCount() {
-		return 0;
-	}
-	isPeerOnline(pubkey) {
-		return false;
-	}
-	getPeer(pubkey) {
-		return this.peers.find((p) => p.pubkey === pubkey);
-	}
-	getWarnings() {
-		return [...this.warnings];
-	}
-	async pingPeers() {
-		this.log("warn", "Ping not supported in static peer manager mode");
-		return this.getPeerStatus();
-	}
-	startMonitoring() {
-		this.log("warn", "Live monitoring not available in static peer manager mode");
-	}
-	stopMonitoring() {
-		this.log("warn", "No monitoring to stop in static peer manager mode");
-	}
-	updateConfig(config) {
-		this.log("warn", "Configuration updates not supported in static peer manager mode");
-	}
-	cleanup() {
-		this.peers = [];
-		this.warnings = [];
-	}
-	log(level, message, data) {
-		if (level === "warn" && this.config.suppressWarnings) return;
-		if (this.config.customLogger) this.config.customLogger(level, `[StaticPeerManager] ${message}`, data);
-		else if (this.config.enableLogging) (level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log)(`[StaticPeerManager] [${level.toUpperCase()}] ${message}`, data || "");
-	}
-};
-/**
-* Enhanced peer manager class leveraging the new ping functionality
-*/
-var PeerManager = class {
-	constructor(node, selfPubkey, config = {}) {
-		this.peers = /* @__PURE__ */ new Map();
-		this.node = node;
-		this.selfPubkey = selfPubkey;
-		this.config = {
-			...DEFAULT_PEER_MONITOR_CONFIG,
-			...config
-		};
-		this.messageHandler = this.handleMessage.bind(this);
-		this.pingResponseHandler = this.handlePingResponse.bind(this);
-		this.setupEventListeners();
-	}
-	/**
-	* Handle incoming messages to mark peers as online
-	*/
-	handleMessage(msg) {
-		if (!msg || typeof msg !== "object") return;
-		const peerPubkey = msg.pub || msg.pubkey || msg.from;
-		if (peerPubkey) {
-			const normalizedPubkey = normalizePubkey(peerPubkey);
-			if (this.peers.has(normalizedPubkey)) this.updatePeerStatus(normalizedPubkey, "online");
-		}
-	}
-	/**
-	* Handle ping responses to mark peers as online
-	*/
-	handlePingResponse(msg) {
-		const peerPubkey = msg.pub || msg.pubkey || msg.from;
-		if (peerPubkey) {
-			const normalizedPubkey = normalizePubkey(peerPubkey);
-			if (this.peers.has(normalizedPubkey)) this.updatePeerStatus(normalizedPubkey, "online");
-		}
-	}
-	/**
-	* Set up event listeners for backward compatibility
-	*/
-	setupEventListeners() {
-		this.node.on("message", this.messageHandler);
-		this.node.on("/ping/sender/res", this.pingResponseHandler);
-	}
-	/**
-	* Initialize peer list from group configuration
-	*/
-	initializePeers(groupCredential, shareCredential) {
-		try {
-			const peers = extractPeersFromCredentials(groupCredential, shareCredential);
-			this.initializePeersFromList(peers);
-			if (this.config.autoMonitor) this.startMonitoring();
-		} catch (error) {
-			throw new require_types.NodeError(`Failed to initialize peers: ${error.message}`, {
-				groupCredential,
-				shareCredential,
-				error
-			});
-		}
-	}
-	/**
-	* Initialize peers from a pre-validated list
-	*/
-	initializePeersFromList(peerPubkeys) {
-		this.peers.clear();
-		peerPubkeys.forEach((pubkey) => {
-			const normalizedPubkey = normalizePubkey(pubkey);
-			this.peers.set(normalizedPubkey, {
-				pubkey: normalizedPubkey,
-				status: "unknown",
-				lastSeen: void 0,
-				allowSend: true,
-				allowReceive: true
-			});
-		});
-		this.log("info", `Initialized ${peerPubkeys.length} peers`);
-	}
-	/**
-	* Update the status of a specific peer (public for backward compatibility)
-	*/
-	updatePeerStatus(pubkey, status) {
-		const normalizedPubkey = normalizePubkey(pubkey);
-		const peer = this.peers.get(normalizedPubkey);
-		if (!peer) return;
-		const oldStatus = peer.status;
-		peer.status = status;
-		peer.lastSeen = status === "online" ? /* @__PURE__ */ new Date() : peer.lastSeen;
-		if (oldStatus !== peer.status && this.config.onPeerStatusChange) this.config.onPeerStatusChange(peer);
-	}
-	/**
-	* Update the status of a specific peer from ping result
-	*/
-	updatePeerFromPingResult(result) {
-		const normalizedPubkey = normalizePubkey(result.pubkey);
-		const peer = this.peers.get(normalizedPubkey);
-		if (!peer) return;
-		const oldStatus = peer.status;
-		peer.status = result.success ? "online" : "offline";
-		peer.lastSeen = result.success ? result.timestamp : peer.lastSeen;
-		peer.latency = result.latency;
-		peer.policy = result.policy;
-		if (oldStatus !== peer.status && this.config.onPeerStatusChange) this.config.onPeerStatusChange(peer);
-	}
-	/**
-	* Ping all peers using the new ping functionality
-	*/
-	async pingPeers() {
-		try {
-			const peerPubkeys = Array.from(this.peers.keys());
-			if (peerPubkeys.length === 0) {
-				this.log("warn", "No peers to ping");
-				return this.getPeerStatus();
-			}
-			this.log("debug", `Pinging ${peerPubkeys.length} peers`);
-			(await require_ping.pingPeers(this.node, peerPubkeys, {
-				timeout: this.config.pingTimeout,
-				eventConfig: { enableLogging: this.config.enableLogging }
-			})).forEach((result) => this.updatePeerFromPingResult(result));
-			const status = this.getPeerStatus();
-			this.log("info", `Ping complete: ${status.onlineCount}/${status.totalPeers} peers online`);
-			return status;
-		} catch (error) {
-			this.handleError(error, "pingPeers");
-			for (const peer of this.peers.values()) peer.status = "unknown";
-			return this.getPeerStatus();
-		}
-	}
-	/**
-	* Get current peer status with enhanced information
-	*/
-	getPeerStatus() {
-		const peers = Array.from(this.peers.values());
-		const onlinePeers = peers.filter((p) => p.status === "online");
-		const offlinePeers = peers.filter((p) => p.status === "offline");
-		const latencies = onlinePeers.map((p) => p.latency).filter((latency) => latency !== void 0);
-		const averageLatency = latencies.length > 0 ? latencies.reduce((sum, latency) => sum + latency, 0) / latencies.length : void 0;
-		return {
-			peers,
-			onlinePeers,
-			offlinePeers,
-			totalPeers: peers.length,
-			onlineCount: onlinePeers.length,
-			lastChecked: /* @__PURE__ */ new Date(),
-			averageLatency
-		};
-	}
-	/**
-	* Start automatic peer monitoring using the ping monitor
-	*/
-	startMonitoring() {
-		if (this.pingMonitor) this.pingMonitor.stop();
-		const peerPubkeys = Array.from(this.peers.keys());
-		if (peerPubkeys.length === 0) {
-			this.log("warn", "No peers to monitor");
-			return;
-		}
-		try {
-			this.pingMonitor = require_ping.createPingMonitor(this.node, peerPubkeys, {
-				interval: this.config.pingInterval,
-				timeout: this.config.pingTimeout,
-				onPingResult: (result) => {
-					this.updatePeerFromPingResult(result);
-				},
-				onError: (error, context) => {
-					this.handleError(error, `monitor:${context}`);
-				},
-				eventConfig: { enableLogging: this.config.enableLogging }
-			});
-			this.pingMonitor.start();
-			this.log("info", `Started monitoring ${peerPubkeys.length} peers (interval: ${this.config.pingInterval}ms)`);
-		} catch (error) {
-			this.handleError(error, "startMonitoring");
-			throw new require_types.NodeError(`Failed to start peer monitoring: ${error.message}`, { error });
-		}
-	}
-	/**
-	* Stop automatic peer monitoring
-	*/
-	stopMonitoring() {
-		if (this.pingMonitor) {
-			this.pingMonitor.stop();
-			this.log("info", "Stopped peer monitoring");
-		}
-	}
-	/**
-	* Update monitoring configuration
-	*/
-	updateConfig(config) {
-		const wasMonitoring = this.pingMonitor?.isRunning;
-		this.config = {
-			...this.config,
-			...config
-		};
-		if (wasMonitoring && (config.pingInterval || config.pingTimeout)) {
-			this.stopMonitoring();
-			this.startMonitoring();
-		}
-	}
-	/**
-	* Ping a specific peer
-	*/
-	async pingPeer(pubkey) {
-		if (!this.peers.has(pubkey)) throw new require_types.NodeError(`Peer not found: ${pubkey}`, { pubkey });
-		try {
-			const result = await require_ping.pingPeer(this.node, pubkey, {
-				timeout: this.config.pingTimeout,
-				eventConfig: { enableLogging: this.config.enableLogging }
-			});
-			this.updatePeerFromPingResult(result);
-			return result;
-		} catch (error) {
-			this.handleError(error, "pingPeer");
-			throw error;
-		}
-	}
-	/**
-	* Get a specific peer by public key
-	*/
-	getPeer(pubkey) {
-		return this.peers.get(pubkey);
-	}
-	/**
-	* Get all peers
-	*/
-	getAllPeers() {
-		return Array.from(this.peers.values());
-	}
-	/**
-	* Get online peers only
-	*/
-	getOnlinePeers() {
-		return Array.from(this.peers.values()).filter((p) => p.status === "online");
-	}
-	/**
-	* Get offline peers only
-	*/
-	getOfflinePeers() {
-		return Array.from(this.peers.values()).filter((p) => p.status === "offline");
-	}
-	/**
-	* Check if a specific peer is online
-	*/
-	isPeerOnline(pubkey) {
-		return this.peers.get(pubkey)?.status === "online" || false;
-	}
-	/**
-	* Get the count of online peers
-	*/
-	getOnlineCount() {
-		return Array.from(this.peers.values()).filter((p) => p.status === "online").length;
-	}
-	/**
-	* Cleanup resources
-	*/
-	cleanup() {
-		const nodeAny = this.node;
-		if (typeof nodeAny.off === "function") {
-			nodeAny.off("message", this.messageHandler);
-			nodeAny.off("/ping/sender/res", this.pingResponseHandler);
-		} else if (typeof nodeAny.removeListener === "function") {
-			nodeAny.removeListener("message", this.messageHandler);
-			nodeAny.removeListener("/ping/sender/res", this.pingResponseHandler);
-		} else if (typeof nodeAny.removeAllListeners === "function") {
-			nodeAny.removeAllListeners("message");
-			nodeAny.removeAllListeners("/ping/sender/res");
-		}
-		this.stopMonitoring();
-		if (this.pingMonitor) {
-			this.pingMonitor.cleanup();
-			this.pingMonitor = void 0;
-		}
-		this.peers.clear();
-		this.log("info", "Peer manager cleaned up");
-	}
-	/**
-	* Handle errors with optional callback
-	*/
-	handleError(error, context) {
-		if (this.config.onError) this.config.onError(error, context);
-		else this.log("error", `Error in ${context}: ${error.message}`);
-	}
-	/**
-	* Internal logging
-	*/
-	log(level, message, data) {
-		if (level === "warn" && this.config.suppressWarnings) return;
-		if (this.config.customLogger) this.config.customLogger(level, `[PeerManager] ${message}`, data);
-		else if (this.config.enableLogging) (level === "error" ? console.error : level === "warn" ? console.warn : level === "debug" ? console.debug : console.log)(`[PeerManager] [${level.toUpperCase()}] ${message}`, data || "");
-	}
-};
-/**
-* Extract peers from group credentials using improved error handling
-*/
-function extractPeersFromCredentials(groupCredential, shareCredential) {
-	try {
-		return extractPeersFromGroup(require_keyset.decodeGroup(groupCredential), extractSelfPubkey(require_keyset.decodeShare(shareCredential)));
-	} catch (error) {
-		throw new require_types.NodeError(`Failed to extract peers from credentials: ${error.message}`, {
-			groupCredential,
-			shareCredential,
-			error
-		});
-	}
-}
-/**
-* Extract self public key from share with multiple strategies
-*/
-function extractSelfPubkey(share) {
-	const shareAny = share;
-	if (shareAny.pubkey && typeof shareAny.pubkey === "string") return shareAny.pubkey;
-	if (shareAny.pub && typeof shareAny.pub === "string") return shareAny.pub;
-	if (shareAny.public_key && typeof shareAny.public_key === "string") return shareAny.public_key;
-	throw new require_types.NodeError("Could not extract self public key from share credential", { availableFields: Object.keys(shareAny) });
-}
-/**
-* Extract peers from group package
-*/
-function extractPeersFromGroup(group, selfPubkey) {
-	const groupAny = group;
-	let allPubkeys = [];
-	if (group.commits && Array.isArray(group.commits)) {
-		const commitPubkeys = group.commits.map((commit) => commit?.pubkey).filter((pubkey) => pubkey && typeof pubkey === "string" && pubkey.length > 0);
-		allPubkeys.push(...commitPubkeys);
-	}
-	if (allPubkeys.length === 0 && groupAny.participants && Array.isArray(groupAny.participants)) {
-		const participantPubkeys = groupAny.participants.filter((pubkey) => pubkey && typeof pubkey === "string" && pubkey.length > 0);
-		allPubkeys.push(...participantPubkeys);
-	}
-	if (allPubkeys.length === 0 && groupAny.members && Array.isArray(groupAny.members)) {
-		const memberPubkeys = groupAny.members.map((member) => {
-			if (typeof member === "string") return member;
-			if (member?.pubkey) return member.pubkey;
-			if (member?.pub) return member.pub;
-			return null;
-		}).filter((pubkey) => pubkey && typeof pubkey === "string" && pubkey.length > 0);
-		allPubkeys.push(...memberPubkeys);
-	}
-	if (allPubkeys.length === 0) throw new require_types.NodeError("No peer public keys found in group", {
-		checkedFields: [
-			"commits",
-			"participants",
-			"members"
-		],
-		groupStructure: Object.keys(groupAny)
-	});
-	return [...new Set(allPubkeys)].filter((pubkey) => pubkey !== selfPubkey);
-}
-/**
-* Simple function to ping peers and get online peer pubkeys (legacy compatibility)
-* @deprecated Use PeerManager.pingPeers() or pingPeersInternal() instead
-*/
-async function pingPeers(node, timeout = require_ping.DEFAULT_PING_TIMEOUT) {
-	try {
-		const result = await node.req?.ping?.();
-		if (result && result.ok) {
-			if (Array.isArray(result.data)) return result.data;
-			else if (result.data && typeof result.data === "object") return Object.keys(result.data);
-		}
-		return [];
-	} catch (error) {
-		console.warn("Ping operation failed:", error);
-		return [];
-	}
-}
-/**
-* Create a PeerManager instance with a connected BifrostNode
-*/
-async function createPeerManager(node, groupCredential, shareCredential, config = {}) {
-	try {
-		const validation = await validatePeerCredentials(groupCredential, shareCredential);
-		if (!validation.isValid) throw new require_types.NodeError(`Invalid credentials: ${validation.error}`, { validation });
-		const peerManager = new PeerManager(node, validation.selfPubkey, config);
-		peerManager.initializePeersFromList(validation.peers);
-		return peerManager;
-	} catch (error) {
-		throw new require_types.NodeError(`Failed to create peer manager: ${error.message}`, {
-			groupCredential,
-			shareCredential,
-			error
-		});
-	}
-}
-/**
-* Simple peer status check function using ping functionality
-*/
-async function checkPeerStatus(node, groupCredential, shareCredential) {
-	try {
-		return (await require_ping.pingPeers(node, extractPeersFromCredentials(groupCredential, shareCredential), {
-			timeout: require_ping.DEFAULT_PING_TIMEOUT,
-			eventConfig: { enableLogging: false }
-		})).map((result) => ({
-			pubkey: result.pubkey,
-			status: result.success ? "online" : "offline"
-		}));
-	} catch (error) {
-		throw new require_types.NodeError(`Failed to check peer status: ${error.message}`, {
-			groupCredential,
-			shareCredential,
-			error
-		});
-	}
-}
-/**
-* Validate peer credentials before creating peer manager
-*/
-async function validatePeerCredentials(groupCredential, shareCredential) {
-	const warnings = [];
-	try {
-		let group;
-		try {
-			group = require_keyset.decodeGroup(groupCredential);
-		} catch (error) {
-			return {
-				isValid: false,
-				error: `Invalid group credential: ${error instanceof Error ? error.message : "Unknown error"}`,
-				peerCount: 0,
-				peers: [],
-				warnings
-			};
-		}
-		let share;
-		try {
-			share = require_keyset.decodeShare(shareCredential);
-		} catch (error) {
-			return {
-				isValid: false,
-				error: `Invalid share credential: ${error instanceof Error ? error.message : "Unknown error"}`,
-				peerCount: 0,
-				peers: [],
-				warnings
-			};
-		}
-		let selfPubkey;
-		try {
-			selfPubkey = extractSelfPubkey(share);
-		} catch (error) {
-			return {
-				isValid: false,
-				error: `Could not extract self public key: ${error instanceof Error ? error.message : "Unknown error"}`,
-				peerCount: 0,
-				peers: [],
-				warnings
-			};
-		}
-		let peers;
-		try {
-			peers = extractPeersFromGroup(group, selfPubkey);
-		} catch (error) {
-			return {
-				isValid: false,
-				error: `Peer extraction failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-				peerCount: 0,
-				peers: [],
-				warnings
-			};
-		}
-		if (peers.length === 0) warnings.push("No other peers found in group - this might be a single-member group");
-		else if (peers.length === 1) warnings.push("Only one other peer found in group");
-		return {
-			isValid: true,
-			peerCount: peers.length,
-			peers,
-			selfPubkey,
-			warnings
-		};
-	} catch (error) {
-		return {
-			isValid: false,
-			error: `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-			peerCount: 0,
-			peers: [],
-			warnings
-		};
-	}
-}
-/**
-* Enhanced peer manager creation with robust error handling and fallback options
-*/
-async function createPeerManagerRobust(node, groupCredential, shareCredential, config) {
-	const enhancedConfig = {
-		...DEFAULT_PEER_MONITOR_CONFIG,
-		...config
-	};
-	try {
-		const selfPubkeyResult = extractSelfPubkeyFromCredentials(groupCredential, shareCredential, {
-			normalize: true,
-			suppressWarnings: enhancedConfig.suppressWarnings
-		});
-		const validation = await validatePeerCredentials(groupCredential, shareCredential);
-		if (!validation.isValid) if (enhancedConfig.fallbackMode === "static") try {
-			return {
-				success: true,
-				peerManager: new StaticPeerManager(extractBasicPeers(groupCredential, shareCredential), [...enhancedConfig.suppressWarnings ? [] : [`Live monitoring disabled: ${validation.error}`], ...enhancedConfig.suppressWarnings ? [] : ["Using static peer list as fallback"]], enhancedConfig),
-				mode: "static",
-				warnings: enhancedConfig.suppressWarnings ? [] : [`Peer monitoring disabled: ${validation.error}`, "Fallback to static peer list enabled"]
-			};
-		} catch (fallbackError) {
-			return {
-				success: false,
-				error: `Primary and fallback failed: ${validation.error}`,
-				mode: "failed"
-			};
-		}
-		else return {
-			success: false,
-			error: validation.error,
-			mode: "failed"
-		};
-		try {
-			const peerManager = new PeerManager(node, selfPubkeyResult.pubkey || validation.selfPubkey, {
-				...enhancedConfig,
-				autoMonitor: false
-			});
-			const normalizedPeers = validation.peers.map((pubkey) => normalizePubkey(pubkey));
-			peerManager.initializePeersFromList(normalizedPeers);
-			if (enhancedConfig.autoMonitor) try {
-				peerManager.startMonitoring();
-			} catch (monitorError) {
-				if (enhancedConfig.onError) enhancedConfig.onError(monitorError, "startMonitoring");
-				if (enhancedConfig.fallbackMode === "static") return {
-					success: true,
-					peerManager: new StaticPeerManager(normalizedPeers, [...enhancedConfig.suppressWarnings ? [] : [`Live monitoring failed: ${monitorError instanceof Error ? monitorError.message : "Unknown error"}`], ...enhancedConfig.suppressWarnings ? [] : ["Switched to static peer list mode"]], enhancedConfig),
-					mode: "static",
-					warnings: enhancedConfig.suppressWarnings ? [] : [`Monitoring initialization failed, using static mode`, ...validation.warnings || []]
-				};
-				else throw monitorError;
-			}
-			return {
-				success: true,
-				peerManager,
-				mode: "full",
-				warnings: enhancedConfig.suppressWarnings ? [] : [...selfPubkeyResult.warnings, ...validation.warnings || []]
-			};
-		} catch (managerError) {
-			if (enhancedConfig.onError) enhancedConfig.onError(managerError, "createPeerManager");
-			if (enhancedConfig.fallbackMode === "static") return {
-				success: true,
-				peerManager: new StaticPeerManager(validation.peers.map((pubkey) => normalizePubkey(pubkey)), [...enhancedConfig.suppressWarnings ? [] : [`PeerManager creation failed: ${managerError instanceof Error ? managerError.message : "Unknown error"}`], ...enhancedConfig.suppressWarnings ? [] : ["Using static peer list as fallback"]], enhancedConfig),
-				mode: "static",
-				warnings: enhancedConfig.suppressWarnings ? [] : [`Full peer manager creation failed, using static mode`, ...validation.warnings || []]
-			};
-			else throw managerError;
-		}
-	} catch (error) {
-		if (enhancedConfig.onError) enhancedConfig.onError(error, "createPeerManagerRobust");
-		return {
-			success: false,
-			error: `Peer manager creation failed: ${error instanceof Error ? error.message : "Unknown error"}`,
-			mode: "failed"
-		};
-	}
-}
-/**
-* Basic peer extraction for fallback scenarios
-*/
-function extractBasicPeers(groupCredential, shareCredential) {
-	try {
-		return extractPeersFromCredentials(groupCredential, shareCredential);
-	} catch (error) {
-		try {
-			const group = require_keyset.decodeGroup(groupCredential);
-			const groupAny = group;
-			if (groupAny.participants && Array.isArray(groupAny.participants)) return groupAny.participants.filter((p) => p && typeof p === "string");
-			if (group.commits && Array.isArray(group.commits)) return group.commits.map((c) => c?.pubkey).filter((p) => p && typeof p === "string");
-			return [];
-		} catch {
-			return [];
-		}
-	}
-}
-
-//#endregion
-Object.defineProperty(exports, 'DEFAULT_PEER_MONITOR_CONFIG', {
-  enumerable: true,
-  get: function () {
-    return DEFAULT_PEER_MONITOR_CONFIG;
-  }
-});
-Object.defineProperty(exports, 'PeerManager', {
-  enumerable: true,
-  get: function () {
-    return PeerManager;
-  }
-});
-Object.defineProperty(exports, 'StaticPeerManager', {
-  enumerable: true,
-  get: function () {
-    return StaticPeerManager;
-  }
-});
-Object.defineProperty(exports, 'addPubkeyPrefix', {
-  enumerable: true,
-  get: function () {
-    return addPubkeyPrefix;
-  }
-});
-Object.defineProperty(exports, 'checkPeerStatus', {
-  enumerable: true,
-  get: function () {
-    return checkPeerStatus;
-  }
-});
-Object.defineProperty(exports, 'comparePubkeys', {
-  enumerable: true,
-  get: function () {
-    return comparePubkeys;
-  }
-});
-Object.defineProperty(exports, 'createPeerManager', {
-  enumerable: true,
-  get: function () {
-    return createPeerManager;
-  }
-});
-Object.defineProperty(exports, 'createPeerManagerRobust', {
-  enumerable: true,
-  get: function () {
-    return createPeerManagerRobust;
-  }
-});
-Object.defineProperty(exports, 'extractPeersFromCredentials', {
-  enumerable: true,
-  get: function () {
-    return extractPeersFromCredentials;
-  }
-});
-Object.defineProperty(exports, 'extractSelfPubkeyFromCredentials', {
-  enumerable: true,
-  get: function () {
-    return extractSelfPubkeyFromCredentials;
-  }
-});
-Object.defineProperty(exports, 'normalizePubkey', {
-  enumerable: true,
-  get: function () {
-    return normalizePubkey;
-  }
-});
-Object.defineProperty(exports, 'pingPeers', {
-  enumerable: true,
-  get: function () {
-    return pingPeers;
-  }
-});
-Object.defineProperty(exports, 'validatePeerCredentials', {
-  enumerable: true,
-  get: function () {
-    return validatePeerCredentials;
-  }
-});
-//# sourceMappingURL=peer-XrPL0O6z.cjs.map