Struct ResonanceState 

pub struct ResonanceState {
    pub instance_id: u64,
    pub outgoing: Vec<Pulse>,
    pub incoming: Vec<ReceivedPulse>,
    pub field: HashMap<(i16, i16, i16), f32>,
}

Resonance protocol state.

Fields

instance_id: u64

Our instance ID.

outgoing: Vec<Pulse>

Outgoing pulses (emitted by this instance, ready to share).

incoming: Vec<ReceivedPulse>

Incoming pulses (received from other instances).

field: HashMap<(i16, i16, i16), f32>

Per-coordinate resonance field: accumulates pulse energy at spatial positions. Key: quantized (x, y, z) at resolution 0.05, Value: accumulated strength.

Implementations

impl ResonanceState

pub fn load_or_init(output_dir: &Path) -> Self

Load or initialize resonance state.

pub fn emit_pulse( &mut self, activations: &[(u32, f32)], query_hash: u64, headers: &[(f32, f32, f32)], layer_hint: u8, )

Emit a pulse from a local query activation. headers maps block indices to their (x, y, z) coordinates.

pub fn receive_pulse( &mut self, pulse: Pulse, local_headers: &[(f32, f32, f32)], proximity_threshold: f32, ) -> u32

Receive a pulse from another instance. Returns the number of local blocks influenced.

pub fn integrate_into_hebbian( &mut self, hebb: &mut HebbianState, local_headers: &[(f32, f32, f32)], proximity_threshold: f32, ) -> usize

Integrate received pulses into Hebbian state. Blocks near pulse activation coordinates get a small energy boost.

pub fn field_strength(&self, x: f32, y: f32, z: f32) -> f32

Get the resonance field strength at a spatial position.

pub fn decay_field(&mut self, factor: f32)

Decay the resonance field (call periodically).

pub fn expire_pulses(&mut self)

Expire old pulses.

pub fn stats(&self) -> ResonanceStats

Get statistics.

pub fn export_pulses(&self) -> Vec<u8>

Export outgoing pulses as wire-format bytes for federation.

pub fn import_pulses(data: &[u8]) -> Vec<Pulse>

Import pulses from wire-format bytes (from another instance).

pub fn save(&self, output_dir: &Path) -> Result<(), String>

Save state to disk.