//! # chronogrid_net
//!
//! P2P mesh networking layer for ChronoGrid.
//!
//! Provides libp2p-based peer discovery and CRDT delta synchronization over
//! QUIC with Noise XK encryption.
//!
//! ## Module Overview
//!
//! | Module          | Responsibility                                                    |
//! |-----------------|-------------------------------------------------------------------|
//! | [`error`]       | Unified error type (`NetError`) and `NetResult<T>` alias         |
//! | [`identity`]    | Ed25519 node keypair, `NodeId` derivation, file persistence       |
//! | [`swarm_key`]   | 256-bit pre-shared `SwarmKey` for cluster authentication          |
//! | [`peer_event`]  | `PeerEvent` enum — unified peer lifecycle events                  |
//! | [`transport`]   | TCP + Noise XK + Yamux transport builder; keypair conversion      |
//! | [`discovery`]   | `MdnsDiscovery` (LAN) and `KademliaDht` (WAN) peer discovery      |
//! | [`sync`]        | `VectorClock`, `DeltaPacket`, `SyncProtocol`, `GossipsubBroadcast`, `NetEvent` |
//! | [`swarm_manager`] | `SwarmManager` event loop, `SwarmHandle` public API, `ChronoGridBehaviour` composite |
//!
//! ## Quick Start
//!
//! ```rust,no_run
//! use std::path::Path;
//! use chronogrid_net::identity::load_or_create_identity;
//! use chronogrid_net::swarm_key::SwarmKey;
//! use chronogrid_net::transport::{build_transport, TransportConfig};
//! use chronogrid_net::sync::{VectorClock, DeltaPacket, SyncProtocol};
//! use chronogrid_net::swarm_manager::{SwarmManager, SwarmHandle};
//!
//! // Load or generate a persistent node identity.
//! let identity = load_or_create_identity(Path::new("/var/lib/chronogrid/identity.json"))
//!     .expect("identity");
//! println!("Node ID: {}", identity.node_id());
//!
//! // Load or generate the cluster swarm key.
//! let swarm_key = SwarmKey::load_or_create(Path::new("/var/lib/chronogrid/swarm.key"))
//!     .expect("swarm key");
//! println!("Swarm fingerprint: {}", swarm_key.fingerprint());
//!
//! // Build the TCP + Noise transport.
//! let transport = build_transport(&identity, &swarm_key).expect("transport");
//!
//! // Build the transport config (used by SwarmManager).
//! let config = TransportConfig::from_swarm_key(&swarm_key);
//! println!("User-agent: {}", config.user_agent());
//!
//! // Build a vector clock for delta sync.
//! let mut clock = VectorClock::new();
//! clock.update("entity-uuid-1", "1724000000000-0001-ab12");
//! ```

pub mod discovery;
pub mod error;
pub mod identity;
pub mod peer_event;
pub mod swarm_key;
pub mod swarm_manager;
pub mod sync;
pub mod transport;

// Re-export the most commonly used types at the crate root for convenience.
pub use error::{NetError, NetResult};
pub use identity::{NodeId, NodeIdentity};
pub use peer_event::PeerEvent;
pub use swarm_key::SwarmKey;
pub use swarm_manager::{ChronoGridBehaviour, SwarmHandle, SwarmManager};
pub use sync::{DeltaPacket, GossipEvent, NetEvent, SyncProtocol, VectorClock};
pub use transport::{TransportConfig, build_transport, peer_id_from_identity};

/// Re-export `libp2p::PeerId` and `libp2p::Multiaddr` so downstream crates
/// (e.g. `chronogrid_core` tests and `chronogrid_daemon`) can use them without
/// a direct `libp2p` dependency.
pub use libp2p::{Multiaddr, PeerId};