Struct ArrayInbound 

pub struct ArrayInbound<S: StorageEngine> { /* private fields */ }

Dispatcher for inbound array CRDT wire messages from Origin.

Each handle_* method (defined in sibling modules) is stateless from the transport layer’s perspective — callers pass the already-decoded wire message and receive an InboundOutcome.

Snapshot state is buffered internally in snapshots until all chunks for a given (array, snapshot_hlc) have arrived.

Implementations

impl<S: StorageEngine> ArrayInbound<S>

pub fn handle_delta( &self, msg: &ArrayDeltaMsg, ) -> Result<InboundOutcome, LiteError>

Apply a single delta message from Origin.

Decodes the op payload, observes the HLC, then delegates to nodedb_array::sync::apply::apply_op.

pub fn handle_delta_batch( &self, msg: &ArrayDeltaBatchMsg, ) -> Result<Vec<InboundOutcome>, LiteError>

Apply a batch of delta messages from Origin.

Returns one InboundOutcome per op payload in the batch.

impl<S: StorageEngine> ArrayInbound<S>

pub fn new( engine: Arc<LiteApplyEngine<S>>, schemas: Arc<SchemaRegistry<S>>, replica: Arc<ReplicaState>, pending: Arc<PendingQueue<S>>, catchup: Arc<CatchupTracker<S>>, ) -> Self

Construct from the component parts shared with NodeDbLite.

pub fn replica_id(&self) -> u64

The stable replica identity for this Lite peer.

Used by the transport layer to construct ArrayAckMsg bodies.

impl<S: StorageEngine> ArrayInbound<S>

pub async fn handle_reject( &self, msg: &ArrayRejectMsg, ) -> Result<InboundOutcome, LiteError>

Process a reject message from Origin.

• Drop: removes the op from the pending queue and logs the loss at error level.
• CatchUp: persists the array’s catch-up flag, so the next catch-up request starts at Hlc::ZERO.
• ResendSchema and Park: keep the op queued and log the reject.

Returns InboundOutcome::RejectAcknowledged in every case, including a Drop for an op no longer queued.

impl<S: StorageEngine> ArrayInbound<S>

pub fn catchup_tracker(&self) -> &Arc<CatchupTracker<S>>

The per-array high-water mark of ops applied from Origin.

pub fn begin_catchup_round( &self, ) -> Result<Vec<ArrayCatchupRequestMsg>, LiteError>

Start the catch-up round for a new session.

Drops partial snapshot assemblies left by the previous session, then returns one ArrayCatchupRequestMsg per array in the local schema registry, sorted by name. Each request starts at the tracker’s last-seen HLC, or at nodedb_array::sync::hlc::Hlc::ZERO for an array a RetentionFloor reject flagged. Returns an empty list when the replica holds no arrays.

impl<S: StorageEngine> ArrayInbound<S>

pub async fn handle_schema( &self, msg: &ArraySchemaSyncMsg, ) -> Result<InboundOutcome, LiteError>

Import a schema CRDT snapshot from Origin.

Updates the local crate::sync::array::SchemaRegistry with the Loro snapshot payload. After import, ops targeting this array that previously returned SchemaTooNew may succeed on retry.

impl<S: StorageEngine> ArrayInbound<S>

pub fn handle_snapshot_header( &self, msg: &ArraySnapshotMsg, ) -> Result<InboundOutcome, LiteError>

Buffer an incoming snapshot header.

Must arrive before any Self::handle_snapshot_chunk calls for the same (array, snapshot_hlc); Origin sends the header first on the same ordered stream. A repeated header restarts the assembly, so a transfer Origin re-sends after a reconnect never mixes with stale chunks. Returns SnapshotPartial { received: 0, total }.

pub fn handle_snapshot_chunk( &self, msg: &ArraySnapshotChunkMsg, ) -> Result<InboundOutcome, LiteError>

Buffer a snapshot chunk and, when all chunks have arrived, assemble and apply the snapshot.

Returns InboundOutcome::SnapshotPartial until the last chunk arrives, then returns InboundOutcome::SnapshotApplied after all ops in the assembled snapshot have been applied. A chunk that does not match its header is an error and drops the assembly. A complete assembly leaves the buffer before it is decoded, so a decode or apply error never leaves chunks behind.

pub fn discard_partial_snapshots(&self) -> Result<(), LiteError>

Drop every partial snapshot assembly.

Called when a new session starts its catch-up round. Origin re-sends a whole snapshot for each catch-up request, so a partial assembly from a closed session can never complete.