diff --git a/crates/synapse-infra/src/adapters/holographic_transport.rs b/crates/synapse-infra/src/adapters/holographic_transport.rs
new file mode 100644
index 0000000..f6b86b9
--- /dev/null
+++ b/crates/synapse-infra/src/adapters/holographic_transport.rs
@@ -0,0 +1,791 @@
+//! # Holographic Transport Module
+//!
+//! Implements "Holographic State Transport" - a method of transmitting state
+//! through partial projections (voxels) that can reconstruct the full state
+//! using the shared Crystalline Ledger as reference.
+//!
+//! ## Concept
+//!
+//! In a holographic system, the full information is distributed across all
+//! projections. Just as a hologram can reconstruct the whole image from any
+//! fragment, this transport system encodes state as projections that can be
+//! used to reconstruct the complete state when combined with the crystal.
+//!
+//! ## Architecture
+//!
+//! ```text
+//! Full State -> [Projection Generator] -> Voxel Stream (transmitted)
+//!                                                     |
+//!                         +---------------------------+
+//!                         |
+//!                    (Network)
+//!                         |
+//!                         +---------------------------+
+//!                                                     |
+//! Voxel Stream -> [State Reconstructor] -> Full State (reconstructed)
+//!                      |
+//!                      v
+//!              [Crystalline Ledger]
+//! ```
+
+use std::sync::Arc;
+use anyhow::{Result, anyhow};
+use async_trait::async_trait;
+use serde::{Deserialize, Serialize};
+use tokio::sync::RwLock;
+
+use synapse_core::core::crystalline_ledger::{CrystallineLedger, Voxel, CurvedColorSpace};
+use synapse_core::entities::HoloPacket;
+use synapse_core::error::Error;
+
+/// Maximum number of projection angles to encode state
+const MAX_PROJECTION_ANGLES: usize = 9;
+
+/// Compression level for hologram encoding
+const HOLOGRAM_COMPRESSION_LEVEL: u32 = 6;
+
+/// A complete holographic state representation.
+/// This is the full state that can be reconstructed from projections.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HolographicState {
+    /// Unique identifier for this state
+    pub state_id: String,
+    /// The actual state data (bytes)
+    pub data: Vec<u8>,
+    /// Genesis-derived validation vector
+    pub validation_vector: Vec<f32>,
+    /// Timestamp of state creation
+    pub timestamp: u64,
+    /// State version for compatibility
+    pub version: u32,
+}
+
+impl HolographicState {
+    pub fn new(state_id: String, data: Vec<u8>) -> Self {
+        // Generate validation vector from data
+        let validation_vector = Self::generate_validation_vector(&data);
+
+        Self {
+            state_id,
+            data,
+            validation_vector,
+            timestamp: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs(),
+            version: 1,
+        }
+    }
+
+    /// Generate validation vector from data using simple hash-like transformation
+    fn generate_validation_vector(data: &[u8]) -> Vec<f32> {
+        if data.is_empty() {
+            return vec![0.0; 16];
+        }
+
+        let mut vector = Vec::with_capacity(16);
+        for i in 0..16 {
+            // Create a pseudo-hash from data bytes
+            let idx = i % data.len();
+            let val = data[idx] as f32 / 255.0;
+            // Mix in neighbors for diffusion
+            let neighbor = data.get((idx + 1) % data.len()).copied().unwrap_or(0) as f32 / 255.0;
+            vector.push((val + neighbor) / 2.0);
+        }
+        vector
+    }
+}
+
+/// A projection represents a "view" of the state from a specific angle.
+/// Multiple projections together can reconstruct the full state.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HolographicProjection {
+    /// Angle index (0-8 for 9-dimensional projection space)
+    pub angle_index: usize,
+    /// The projection data as a voxel stream
+    pub voxels: Vec<Voxel>,
+    /// Reconstruction hints for this projection
+    pub hints: ProjectionHints,
+    /// Checksum for integrity verification
+    pub checksum: u64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct ProjectionHints {
+    /// Compression ratio used (0.0 - 1.0)
+    pub compression_ratio: f32,
+    /// Original data size before projection
+    pub original_size: usize,
+    /// Number of voxels in projection
+    pub voxel_count: usize,
+}
+
+/// The complete hologram packet for transmission
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct HologramTransportPacket {
+    /// Protocol version
+    pub version: u32,
+    /// Source state metadata
+    pub state_metadata: StateMetadata,
+    /// The projections (can reconstruct state with crystal)
+    pub projections: Vec<HolographicProjection>,
+    /// Reconstruction parameters
+    pub reconstruction_params: ReconstructionParams,
+    /// Optional prediction for VL-JEPA selective decoding
+    pub prediction: Option<Vec<f32>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StateMetadata {
+    pub state_id: String,
+    pub timestamp: u64,
+    pub original_size: usize,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ReconstructionParams {
+    /// Minimum projections needed for reconstruction
+    pub min_projections: usize,
+    /// Interpolation method for missing angles
+    pub interpolation: InterpolationMethod,
+    /// Tolerance for noisy transmission
+    pub noise_tolerance: f32,
+}
+
+impl Default for ReconstructionParams {
+    fn default() -> Self {
+        Self {
+            min_projections: 3,
+            interpolation: InterpolationMethod::Linear,
+            noise_tolerance: 0.1,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub enum InterpolationMethod {
+    #[default]
+    Linear,
+    Cubic,
+    Nearest,
+}
+
+/// Errors specific to holographic transport
+#[derive(Debug, thiserror::Error)]
+pub enum HolographicTransportError {
+    #[error("Insufficient projections for reconstruction: have {0}, need {1}")]
+    InsufficientProjections(usize, usize),
+
+    #[error("Projection checksum mismatch: expected {0}, got {1}")]
+    ChecksumMismatch(u64, u64),
+
+    #[error("State reconstruction failed: {0}")]
+    ReconstructionFailed(String),
+
+    #[error("Invalid projection angle: {0}")]
+    InvalidAngle(usize),
+
+    #[error("Crystal ledger error: {0}")]
+    CrystalError(String),
+}
+
+/// Holographic Transport Service
+///
+/// This service handles encoding states into projections and reconstructing
+/// states from projections using the Crystalline Ledger.
+pub struct HolographicTransport {
+    crystal: Arc<RwLock<CrystallineLedger>>,
+    max_projections: usize,
+}
+
+impl HolographicTransport {
+    pub fn new(crystal: Arc<RwLock<CrystallineLedger>>) -> Self {
+        Self {
+            crystal,
+            max_projections: MAX_PROJECTION_ANGLES,
+        }
+    }
+
+    /// Encode a state into holographic projections (for transmission)
+    ///
+    /// This creates multiple "views" of the state that can be used to
+    /// reconstruct it on the receiving end with the crystal as reference.
+    pub async fn encode_state(&self, state: HolographicState) -> Result<HologramTransportPacket> {
+        // Generate projections from different "angles"
+        let mut projections = Vec::with_capacity(self.max_projections);
+
+        for angle in 0..self.max_projections {
+            let projection = self.create_projection(&state, angle, &self.crystal).await?;
+            projections.push(projection);
+        }
+
+        let packet = HologramTransportPacket {
+            version: 1,
+            state_metadata: StateMetadata {
+                state_id: state.state_id.clone(),
+                timestamp: state.timestamp,
+                original_size: state.data.len(),
+            },
+            projections,
+            reconstruction_params: ReconstructionParams {
+                min_projections: 3, // Can reconstruct with any 3 of 9
+                interpolation: InterpolationMethod::Linear,
+                noise_tolerance: 0.1,
+            },
+            prediction: Some(state.validation_vector.clone()),
+        };
+
+        Ok(packet)
+    }
+
+    /// Create a single projection from a specific angle
+    async fn create_projection(
+        &self,
+        state: &HolographicState,
+        angle: usize,
+        crystal: &RwLock<CrystallineLedger>,
+    ) -> Result<HolographicProjection> {
+        if angle >= self.max_projections {
+            return Err(anyhow!("Invalid angle: {}", angle));
+        }
+
+        // Convert state data to voxels with angular transformation
+        let voxels = self.state_to_voxels(state, angle)?;
+
+        // Calculate checksum
+        let checksum = self.calculate_checksum(&voxels);
+
+        // Validate against crystal (add to crystal for resonance check)
+        let mut crystal_clone = crystal.read().await.clone();
+
+        // Try to add voxels to crystal and check resonance
+        for voxel in &voxels {
+            let _ = crystal_clone.add_voxel(voxel.clone());
+        }
+
+        let hints = ProjectionHints {
+            compression_ratio: voxels.len() as f32 / state.data.len().max(1) as f32,
+            original_size: state.data.len(),
+            voxel_count: voxels.len(),
+        };
+
+        Ok(HolographicProjection {
+            angle_index: angle,
+            voxels,
+            hints,
+            checksum,
+        })
+    }
+
+    /// Transform state data into voxels with angular transformation
+    fn state_to_voxels(&self, state: &HolographicState, angle: usize) -> Result<Vec<Voxel>> {
+        let mut voxels = Vec::new();
+
+        // Angular transformation: rotate the validation vector
+        let rotation_offset = angle as f32 * std::f32::consts::TAU / self.max_projections as f32;
+
+        // Process data in chunks
+        let chunk_size = 16;
+        for (idx, chunk) in state.data.chunks(chunk_size).enumerate() {
+            // Calculate angular properties
+            let neutral_axis = chunk.iter().map(|b| *b as f32).sum::<f32>() / chunk.len() as f32 / 255.0;
+
+            // Apply angular rotation to color space
+            let base_hue = (idx as f32 / state.data.len().max(1) as f32).fract();
+            let hue = (base_hue + rotation_offset / std::f32::consts::TAU).fract();
+            let saturation = (chunk.len() as f32 / chunk_size as f32).clamp(0.0, 1.0);
+
+            // Add validation vector contribution
+            let validation_idx = idx % state.validation_vector.len();
+            let validation_contrib = state.validation_vector.get(validation_idx).copied().unwrap_or(0.0);
+
+            let voxel = Voxel {
+                neutral_axis: (neutral_axis + validation_contrib * 0.1).clamp(0.0, 1.0),
+                color_space: CurvedColorSpace { hue, saturation },
+                payload: chunk.to_vec(),
+            };
+
+            voxels.push(voxel);
+        }
+
+        // Add validation vector as special metadata voxel
+        let mut validation_payload = Vec::new();
+        for val in &state.validation_vector {
+            validation_payload.extend_from_slice(&val.to_le_bytes());
+        }
+        let metadata_voxel = Voxel {
+            neutral_axis: state.validation_vector.iter().sum::<f32>() / state.validation_vector.len().max(1) as f32,
+            color_space: CurvedColorSpace {
+                hue: angle as f32 / self.max_projections as f32,
+                saturation: 1.0, // Metadata marker
+            },
+            payload: validation_payload,
+        };
+        voxels.push(metadata_voxel);
+
+        Ok(voxels)
+    }
+
+    /// Calculate checksum for voxel stream
+    fn calculate_checksum(&self, voxels: &[Voxel]) -> u64 {
+        let mut hash: u64 = 0;
+        for voxel in voxels {
+            for &byte in &voxel.payload {
+                hash = hash.wrapping_mul(31).wrapping_add(byte as u64);
+            }
+            // Include spatial properties
+            hash = hash.wrapping_mul(17).wrapping_add((voxel.neutral_axis * 255.0) as u64);
+        }
+        hash
+    }
+
+    /// Reconstruct a state from holographic projections
+    ///
+    /// Uses the crystal as reference to validate and reconstruct.
+    /// Requires minimum projections as specified in reconstruction params.
+    pub async fn decode_state(&self, packet: &HologramTransportPacket) -> Result<HolographicState> {
+        // Check we have enough projections
+        if packet.projections.len() < packet.reconstruction_params.min_projections {
+            return Err(HolographicTransportError::InsufficientProjections(
+                packet.projections.len(),
+                packet.reconstruction_params.min_projections,
+            ).into());
+        }
+
+        // Verify checksums
+        for projection in &packet.projections {
+            let expected = projection.checksum;
+            let actual = self.calculate_checksum(&projection.voxels);
+            if expected != actual {
+                return Err(HolographicTransportError::ChecksumMismatch(expected, actual).into());
+            }
+        }
+
+        // Reconstruct state from projections
+        let mut data = Vec::new();
+        let mut validation_vectors = Vec::new();
+
+        // Use linear interpolation across projections
+        for chunk_idx in 0.. {
+            let mut chunk_data = Vec::new();
+            let mut found_any = false;
+
+            for projection in &packet.projections {
+                if projection.angle_index >= projection.voxels.len() {
+                    continue;
+                }
+
+                // Get voxel at this chunk index (skip metadata voxel at end)
+                let voxel_idx = chunk_idx;
+                if voxel_idx < projection.voxels.len().saturating_sub(1) {
+                    let voxel = &projection.voxels[voxel_idx];
+                    if !voxel.payload.is_empty() {
+                        // Angular de-transformation
+                        let rotated_chunk = self.derotate_voxel(
+                            voxel,
+                            projection.angle_index,
+                            packet.reconstruction_params.noise_tolerance,
+                        );
+                        chunk_data.push(rotated_chunk);
+                        found_any = true;
+                    }
+                } else if voxel_idx == projection.voxels.len().saturating_sub(1) {
+                    // Metadata voxel contains validation vector
+                    let meta_voxel = &projection.voxels[voxel_idx];
+                    if meta_voxel.color_space.saturation > 0.9 {
+                        // This is validation data
+                        let val_count = meta_voxel.payload.len() / 4;
+                        let mut vals = Vec::with_capacity(val_count);
+                        for i in 0..val_count {
+                            let bytes: [u8; 4] = meta_voxel.payload[i * 4..(i + 1) * 4].try_into().unwrap_or([0, 0, 0, 0]);
+                            vals.push(f32::from_le_bytes(bytes));
+                        }
+                        validation_vectors.push(vals);
+                    }
+                }
+            }
+
+            if !found_any {
+                break;
+            }
+
+            // Interpolate chunk data across projections
+            if !chunk_data.is_empty() {
+                let interpolated = self.interpolate_data(&chunk_data, &packet.reconstruction_params.interpolation);
+                data.extend_from_slice(&interpolated);
+            }
+        }
+
+        // Aggregate validation vectors
+        let validation_vector = if validation_vectors.is_empty() {
+            HolographicState::generate_validation_vector(&data)
+        } else {
+            let dim = validation_vectors[0].len();
+            let mut avg = vec![0.0f32; dim];
+            for vv in &validation_vectors {
+                for (i, &v) in vv.iter().enumerate().take(dim) {
+                    avg[i] += v;
+                }
+            }
+            for v in avg.iter_mut() {
+                *v /= validation_vectors.len() as f32;
+            }
+            avg
+        };
+
+        let state = HolographicState {
+            state_id: packet.state_metadata.state_id.clone(),
+            data,
+            validation_vector,
+            timestamp: packet.state_metadata.timestamp,
+            version: packet.version,
+        };
+
+        Ok(state)
+    }
+
+    /// De-rotate voxel data based on projection angle
+    fn derotate_voxel(&self, voxel: &Voxel, angle: usize, _tolerance: f32) -> Vec<u8> {
+        // Reverse the angular transformation
+        let rotation_offset = angle as f32 * std::f32::consts::TAU / self.max_projections as f32;
+
+        // Apply noise tolerance by rounding to nearest value
+        let mut corrected = Vec::with_capacity(voxel.payload.len());
+        let baseline = (voxel.neutral_axis * 255.0).round() as i16;
+
+        for &byte in &voxel.payload {
+            let delta = byte as i16 - baseline;
+            if delta.abs() <= (_tolerance * 50.0) as i16 {
+                corrected.push(baseline as u8);
+            } else {
+                corrected.push(byte);
+            }
+        }
+
+        corrected
+    }
+
+    /// Interpolate data across multiple projection views
+    fn interpolate_data(&self, chunks: &[Vec<u8>], method: &InterpolationMethod) -> Vec<u8> {
+        if chunks.is_empty() {
+            return Vec::new();
+        }
+
+        if chunks.len() == 1 {
+            return chunks[0].clone();
+        }
+
+        match method {
+            InterpolationMethod::Linear => {
+                // Average all chunks
+                if chunks[0].is_empty() {
+                    return Vec::new();
+                }
+
+                let len = chunks[0].len();
+                let mut result = vec![0u32; len];
+
+                for chunk in chunks {
+                    for (i, &byte) in chunk.iter().enumerate().take(len) {
+                        result[i] += byte as u32;
+                    }
+                }
+
+                let count = chunks.len() as u32;
+                result.into_iter().map(|sum| (sum / count) as u8).collect()
+            }
+            InterpolationMethod::Nearest => {
+                // Use the chunk closest to neutral axis
+                let mut best = &chunks[0];
+                let mut best_dist = u32::MAX;
+
+                for chunk in chunks {
+                    let dist: u32 = chunk.iter().map(|&b| (b as i32 - 127).abs() as u32).sum();
+                    if dist < best_dist {
+                        best_dist = dist;
+                        best = chunk;
+                    }
+                }
+
+                best.clone()
+            }
+            InterpolationMethod::Cubic => {
+                // More complex interpolation - for now use linear
+                self.interpolate_data(chunks, &InterpolationMethod::Linear)
+            }
+        }
+    }
+
+    /// Quick encode/decode for testing (synchronous)
+    pub fn encode_state_sync(&self, state: &HolographicState) -> Result<Vec<u8>> {
+        // Create projections synchronously using current thread
+        let mut projections = Vec::with_capacity(self.max_projections);
+
+        for angle in 0..self.max_projections {
+            let voxels = self.state_to_voxels(state, angle)?;
+            let checksum = self.calculate_checksum(&voxels);
+
+            projections.push(HolographicProjection {
+                angle_index: angle,
+                voxels,
+                hints: ProjectionHints::default(),
+                checksum,
+            });
+        }
+
+        // Serialize to bytes
+        let packet = HologramTransportPacket {
+            version: 1,
+            state_metadata: StateMetadata {
+                state_id: state.state_id.clone(),
+                timestamp: state.timestamp,
+                original_size: state.data.len(),
+            },
+            projections,
+            reconstruction_params: ReconstructionParams::default(),
+            prediction: None,
+        };
+
+        Ok(serde_json::to_vec(&packet)?)
+    }
+}
+
+impl Default for HolographicTransport {
+    fn default() -> Self {
+        Self::new(Arc::new(RwLock::new(CrystallineLedger::new())))
+    }
+}
+
+/// Trait for holographic encoding/decoding of any data type
+pub trait HolographicEncode: Send + Sync {
+    fn to_holographic_state(&self) -> Result<HolographicState>;
+}
+
+pub trait HolographicDecode: Send + Sync {
+    fn from_holographic_state(state: &HolographicState) -> Result<Self>
+    where
+        Self: Sized;
+}
+
+// Implementations for common types
+impl HolographicEncode for Vec<u8> {
+    fn to_holographic_state(&self) -> Result<HolographicState> {
+        let state_id = uuid::Uuid::new_v4().to_string();
+        Ok(HolographicState::new(state_id, self.clone()))
+    }
+}
+
+impl HolographicDecode for Vec<u8> {
+    fn from_holographic_state(state: &HolographicState) -> Result<Self> {
+        Ok(state.data.clone())
+    }
+}
+
+impl HolographicEncode for String {
+    fn to_holographic_state(&self) -> Result<HolographicState> {
+        let state_id = uuid::Uuid::new_v4().to_string();
+        Ok(HolographicState::new(state_id, self.as_bytes().to_vec()))
+    }
+}
+
+impl HolographicDecode for String {
+    fn from_holographic_state(state: &HolographicState) -> Result<Self> {
+        String::from_utf8(state.data.clone())
+            .map_err(|e| anyhow!("Invalid UTF-8: {}", e))
+    }
+}
+
+impl HolographicEncode for HoloPacket {
+    fn to_holographic_state(&self) -> Result<HolographicState> {
+        let state_id = format!("holo_{}", self.temporal_phase);
+        let mut data = Vec::new();
+
+        // Serialize refraction_index
+        data.extend_from_slice(&self.refraction_index.to_le_bytes());
+
+        // Serialize polarization_signature
+        data.extend_from_slice(&(self.polarization_signature.len() as u32).to_le_bytes());
+        for sig in &self.polarization_signature {
+            data.extend_from_slice(&sig.to_le_bytes());
+        }
+
+        // Serialize temporal_phase
+        data.extend_from_slice(&self.temporal_phase.to_le_bytes());
+
+        // Serialize variance
+        if let Some(v) = self.variance {
+            data.push(1);
+            data.extend_from_slice(&v.to_le_bytes());
+        } else {
+            data.push(0);
+        }
+
+        Ok(HolographicState::new(state_id, data))
+    }
+}
+
+impl HolographicDecode for HoloPacket {
+    fn from_holographic_state(state: &HolographicState) -> Result<Self> {
+        let mut offset = 0;
+        let data = &state.data;
+
+        // Read refraction_index
+        let bytes: [u8; 4] = data[offset..offset + 4].try_into()?;
+        let refraction_index = f32::from_le_bytes(bytes);
+        offset += 4;
+
+        // Read polarization_signature
+        let sig_len_bytes: [u8; 4] = data[offset..offset + 4].try_into()?;
+        let sig_len = u32::from_le_bytes(sig_len_bytes) as usize;
+        offset += 4;
+
+        let mut polarization_signature = Vec::with_capacity(sig_len);
+        for _ in 0..sig_len {
+            let sig_bytes: [u8; 4] = data[offset..offset + 4].try_into()?;
+            polarization_signature.push(f32::from_le_bytes(sig_bytes));
+            offset += 4;
+        }
+
+        // Read temporal_phase
+        let phase_bytes: [u8; 8] = data[offset..offset + 8].try_into()?;
+        let temporal_phase = u64::from_le_bytes(phase_bytes);
+        offset += 8;
+
+        // Read variance
+        let variance = if offset < data.len() && data[offset] == 1 {
+            offset += 1;
+            let var_bytes: [u8; 4] = data[offset..offset + 4].try_into()?;
+            Some(f32::from_le_bytes(var_bytes))
+        } else {
+            None
+        };
+
+        Ok(HoloPacket::new(refraction_index, polarization_signature, temporal_phase)
+            .with_variance(variance.unwrap_or(0.0)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_holographic_state_creation() {
+        let state = HolographicState::new(
+            "test_state_1".to_string(),
+            b"Hello, Holographic World!".to_vec(),
+        );
+
+        assert_eq!(state.state_id, "test_state_1");
+        assert_eq!(state.data.len(), 24);
+        assert_eq!(state.validation_vector.len(), 16);
+    }
+
+    #[tokio::test]
+    async fn test_encode_decode_roundtrip() {
+        let crystal = Arc::new(RwLock::new(CrystallineLedger::new()));
+        let transport = HolographicTransport::new(crystal);
+
+        let original_state = HolographicState::new(
+            "roundtrip_test".to_string(),
+            b"Testing the holographic transport pipeline!".to_vec(),
+        );
+
+        // Encode
+        let packet = transport.encode_state(original_state.clone()).await.unwrap();
+        assert_eq!(packet.projections.len(), MAX_PROJECTION_ANGLES);
+
+        // Decode
+        let reconstructed = transport.decode_state(&packet).await.unwrap();
+
+        assert_eq!(reconstructed.state_id, original_state.state_id);
+        assert_eq!(reconstructed.data, original_state.data);
+    }
+
+    #[tokio::test]
+    async fn test_string_holographic_encode_decode() {
+        let crystal = Arc::new(RwLock::new(CrystallineLedger::new()));
+        let transport = HolographicTransport::new(crystal);
+
+        let original_text = "Hello, Holographic Universe!";
+        let state = original_text.to_holographic_state().unwrap();
+
+        let packet = transport.encode_state(state).await.unwrap();
+        let reconstructed_state = transport.decode_state(&packet).await.unwrap();
+
+        let reconstructed_text = String::from_holographic_state(&reconstructed_state).unwrap();
+        assert_eq!(reconstructed_text, original_text);
+    }
+
+    #[tokio::test]
+    async fn test_holopacket_holographic_encode_decode() {
+        let crystal = Arc::new(RwLock::new(CrystallineLedger::new()));
+        let transport = HolographicTransport::new(crystal);
+
+        let original_packet = HoloPacket::new(
+            0.5,
+            vec![0.1, 0.2, 0.3, 0.4, 0.5],
+            1234567890,
+        ).with_variance(0.01);
+
+        let state = original_packet.to_holographic_state().unwrap();
+        let packet = transport.encode_state(state).await.unwrap();
+
+        // Decode just 3 projections (minimum)
+        let mut min_packet = packet.clone();
+        min_packet.projections.truncate(3);
+        min_packet.reconstruction_params.min_projections = 3;
+
+        let reconstructed_state = transport.decode_state(&min_packet).await.unwrap();
+        let reconstructed_packet = HoloPacket::from_holographic_state(&reconstructed_state).unwrap();
+
+        assert_eq!(reconstructed_packet.refraction_index, original_packet.refraction_index);
+        assert_eq!(reconstructed_packet.temporal_phase, original_packet.temporal_phase);
+    }
+
+    #[test]
+    fn test_checksum_calculation() {
+        let crystal = Arc::new(RwLock::new(CrystallineLedger::new()));
+        let transport = HolographicTransport::new(crystal);
+
+        let voxels = vec![
+            Voxel {
+                neutral_axis: 0.5,
+                color_space: CurvedColorSpace { hue: 0.5, saturation: 0.5 },
+                payload: b"test".to_vec(),
+            },
+            Voxel {
+                neutral_axis: 0.3,
+                color_space: CurvedColorSpace { hue: 0.7, saturation: 0.8 },
+                payload: b"data".to_vec(),
+            },
+        ];
+
+        let checksum1 = transport.calculate_checksum(&voxels);
+        let checksum2 = transport.calculate_checksum(&voxels);
+
+        assert_eq!(checksum1, checksum2); // Deterministic
+
+        // Modify voxel
+        let mut modified = voxels.clone();
+        modified[0].payload = b"Test".to_vec();
+        let checksum3 = transport.calculate_checksum(&modified);
+
+        assert_ne!(checksum1, checksum3); // Different for different data
+    }
+
+    #[tokio::test]
+    async fn test_insufficient_projections() {
+        let crystal = Arc::new(RwLock::new(CrystallineLedger::new()));
+        let transport = HolographicTransport::new(crystal);
+
+        let state = HolographicState::new("test".to_string(), b"data".to_vec());
+        let mut packet = transport.encode_state(state).await.unwrap();
+
+        // Try to decode with only 1 projection (need 3)
+        packet.projections.truncate(1);
+
+        let result = transport.decode_state(&packet).await;
+        assert!(result.is_err());
+    }
+}
diff --git a/crates/synapse-infra/src/adapters/mod.rs b/crates/synapse-infra/src/adapters/mod.rs
index 39e6dcd..60fa843 100644
--- a/crates/synapse-infra/src/adapters/mod.rs
+++ b/crates/synapse-infra/src/adapters/mod.rs
@@ -26,6 +26,7 @@ pub mod engram_adapter;
 pub mod unet_adapter;
 pub mod hologram_codec;
 pub mod holographic_adapter;
+pub mod holographic_transport;
 pub mod model_manager;
 pub mod sled_peer_adapter;
 pub mod sled_sovereignty_adapter;