clm-kernel 0.0.18

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
// Layer 2 outbox orchestration, split out of `service.rs` (Sprint 532).
// Behaviour is unchanged; these are inherent methods on `MCardSyncEngine`.

use crate::layer2::sync::codec::{derive_delivery_id, derive_transfer_id};
use crate::layer2::sync::petri::evaluate_transfer_guard;
use crate::layer2::sync::service::SyncContractError;
use crate::layer2::sync::service::{MCardSyncEngine, TERMINAL_ERROR_CODES};
use crate::layer2::sync::types::{
    RecordFrame, RetryOutcome, SyncOutboxEntry, TransferAttempt, TransferSendResult, TransitionPayload,
};

impl MCardSyncEngine {
    pub fn enqueue_transfer(
        &mut self,
        target_node_id: &str,
        records: Vec<RecordFrame>,
        transitions: Vec<TransitionPayload>,
        disambiguator: &str,
    ) -> Result<SyncOutboxEntry, SyncContractError> {
        let mut sorted_hashes: Vec<String> = records.iter().map(|r| r.hash.clone()).collect();
        sorted_hashes.sort();
        let hashes_json: Vec<String> = sorted_hashes.iter().map(|h| format!("\"{h}\"")).collect();
        let canon = format!(
            "{{\"disambiguator\":\"{}\",\"records\":[{}],\"targetNodeId\":\"{}\",\"transitions\":{}}}",
            disambiguator,
            hashes_json.join(","),
            target_node_id,
            transitions.len()
        );
        let q_ref = format!("blake3:{}", blake3::hash(canon.as_bytes()).to_hex());
        let transfer_id = derive_transfer_id(&q_ref);
        let delivery_id = derive_delivery_id(&q_ref, target_node_id);

        if let Some(existing) = self.outbox.get(&delivery_id) {
            return Ok(existing.clone());
        }

        let previous_marking = self.transfer_marking.clone();
        *self.transfer_marking.entry("p_source".to_string()).or_insert(0) += 1;
        let gate = evaluate_transfer_guard(&self.transfer_marking, "t_enqueue_push", 1);
        if !gate.enabled {
            self.transfer_marking = previous_marking;
            return Err(SyncContractError::new(
                "guard-rejected",
                format!("Enqueue rejected: {}", gate.reason.unwrap_or_else(|| "unknown reason".to_string())),
            ));
        }
        self.transfer_marking = gate.post_marking;

        let entry = SyncOutboxEntry {
            transfer_id,
            delivery_id: delivery_id.clone(),
            target_node_id: target_node_id.to_string(),
            status: "in_flight".to_string(),
            attempt_count: 0,
            records,
            transitions,
            last_error: None,
            error_code: None,
            prior_transfer_id: None,
        };
        self.outbox.insert(delivery_id.clone(), entry.clone());
        if let Err(err) = self.persist_outbox() {
            self.outbox.remove(&delivery_id);
            self.transfer_marking = previous_marking;
            return Err(SyncContractError::new(
                "storage-aborted",
                format!("Failed to persist outbox for {delivery_id}: {err}"),
            ));
        }
        Ok(entry)
    }

    /// Flush eligible outbox entries through the transport. The exact durable
    /// entry must exist before any network I/O; transport errors are treated
    /// as transient and keep the entry retryable.
    pub fn flush_outbox(&mut self) -> Result<Vec<SyncOutboxEntry>, SyncContractError> {
        if self.is_disposed || self.transport.is_none() {
            return Ok(self.outbox.values().cloned().collect());
        }
        let eligible: Vec<String> = self
            .outbox
            .iter()
            .filter(|(_, e)| e.status == "in_flight" || e.status == "queued")
            .map(|(id, _)| id.clone())
            .collect();
        for delivery_id in eligible {
            let entry = match self.outbox.get(&delivery_id) {
                Some(e) => e.clone(),
                None => continue,
            };
            if !self.is_durably_queued(&entry) {
                return Err(SyncContractError::new(
                    "storage-aborted",
                    format!("Durable outbox entry missing or mismatched for {delivery_id}"),
                ));
            }
            let attempt = TransferAttempt {
                transfer_id: entry.transfer_id.clone(),
                delivery_id: entry.delivery_id.clone(),
                source_node_id: self.node_id.clone(),
                target_node_id: entry.target_node_id.clone(),
                record_hashes: entry.records.iter().map(|r| r.hash.clone()).collect(),
                transitions: entry.transitions.clone(),
                attempt_count: entry.attempt_count + 1,
            };
            let res = match self
                .transport
                .as_ref()
                .expect("transport checked")
                .send_transfer(&attempt, &entry.records)
            {
                Ok(r) => r,
                Err(err) => TransferSendResult {
                    ok: false,
                    committed: false,
                    replayed: false,
                    transient: true,
                    error_code: Some("transport-transient".to_string()),
                    reason: Some(err),
                },
            };
            let mut updated = entry.clone();
            updated.attempt_count = attempt.attempt_count;
            if res.ok && res.committed {
                self.transfer_marking =
                    evaluate_transfer_guard(&self.transfer_marking, "t_commit_push", 1).post_marking;
                updated.status = "committed".to_string();
            } else if res.transient {
                self.transfer_marking =
                    evaluate_transfer_guard(&self.transfer_marking, "t_retry", 1).post_marking;
                updated.status = "in_flight".to_string();
                updated.last_error = res.reason.clone();
                updated.error_code =
                    Some(res.error_code.clone().unwrap_or_else(|| "transport-transient".to_string()));
            } else {
                self.transfer_marking =
                    evaluate_transfer_guard(&self.transfer_marking, "t_reject", 1).post_marking;
                updated.status = "rejected".to_string();
                updated.last_error = res.reason.clone();
                updated.error_code =
                    Some(res.error_code.clone().unwrap_or_else(|| "guard-rejected".to_string()));
            }
            self.outbox.insert(delivery_id.clone(), updated);
            if let Err(err) = self.persist_outbox() {
                return Err(SyncContractError::new(
                    "storage-aborted",
                    format!("Failed to persist outbox for {delivery_id}: {err}"),
                ));
            }
        }
        Ok(self.outbox.values().cloned().collect())
    }

    pub fn retry_transfer(&mut self, delivery_id: &str) -> RetryOutcome {
        let Some(entry) = self.outbox.get(delivery_id).cloned() else {
            return RetryOutcome {
                ok: false,
                error_code: Some("guard-rejected".to_string()),
                reason: Some("Transfer is not in rejected status".to_string()),
                ..Default::default()
            };
        };
        if entry.status != "rejected" {
            return RetryOutcome {
                ok: false,
                error_code: Some("guard-rejected".to_string()),
                reason: Some("Transfer is not in rejected status".to_string()),
                ..Default::default()
            };
        }
        if let Some(code) = entry.error_code.as_deref() {
            if TERMINAL_ERROR_CODES.contains(&code) {
                return RetryOutcome {
                    ok: false,
                    error_code: Some(code.to_string()),
                    reason: Some("Terminal integrity failure cannot retry".to_string()),
                    ..Default::default()
                };
            }
        }
        let g1 = evaluate_transfer_guard(&self.transfer_marking, "t_retry_transfer", 1);
        if !g1.enabled {
            return RetryOutcome {
                ok: false,
                error_code: Some("guard-rejected".to_string()),
                reason: g1.reason,
                ..Default::default()
            };
        }
        self.transfer_marking =
            evaluate_transfer_guard(&g1.post_marking, "t_prepare_transfer", 1).post_marking;
        let mut updated = entry.clone();
        updated.status = "in_flight".to_string();
        updated.prior_transfer_id = Some(entry.transfer_id.clone());
        updated.transfer_id = format!("{}:retry:{}", entry.transfer_id, entry.attempt_count);
        self.outbox.insert(delivery_id.to_string(), updated.clone());
        let _ = self.persist_outbox();
        RetryOutcome { ok: true, entry: Some(updated), ..Default::default() }
    }
}