use super::SimpleMlp;
pub(crate) const MODEL_MAGIC: &[u8; 4] = b"BCML";
const MODEL_VERSION: u8 = 1;
const FORMAT_POSTCARD: u8 = 2;
pub(crate) const MODEL_HEADER_SIZE: usize = 44;
#[derive(Debug, thiserror::Error)]
pub enum ModelBinaryError {
#[error("data too short ({0} bytes, need at least {MODEL_HEADER_SIZE})")]
TooShort(usize),
#[error("invalid magic bytes (expected BCML header)")]
BadMagic,
#[error("unsupported model version {0} (expected {MODEL_VERSION})")]
UnsupportedVersion(u8),
#[error(
"unsupported format tag {0} (expected {FORMAT_POSTCARD}; re-save if migrating from bincode)"
)]
UnsupportedFormat(u8),
#[error("BLAKE3 checksum mismatch (data integrity failure)")]
ChecksumMismatch,
#[error("payload too large ({0} bytes, max 4GB)")]
PayloadTooLarge(usize),
#[error("encode error: {0}")]
Encode(String),
#[error("decode error: {0}")]
Decode(String),
}
impl SimpleMlp {
pub fn to_binary(&self) -> Result<Vec<u8>, ModelBinaryError> {
let payload =
postcard::to_allocvec(self).map_err(|e| ModelBinaryError::Encode(e.to_string()))?;
let checksum = blake3::hash(&payload);
let payload_len = u32::try_from(payload.len())
.map_err(|_| ModelBinaryError::PayloadTooLarge(payload.len()))?;
let mut buf = Vec::with_capacity(MODEL_HEADER_SIZE + payload.len());
buf.extend_from_slice(MODEL_MAGIC);
buf.push(MODEL_VERSION);
buf.push(FORMAT_POSTCARD);
buf.extend_from_slice(&[0u8; 2]);
buf.extend_from_slice(&payload_len.to_le_bytes());
buf.extend_from_slice(checksum.as_bytes());
buf.extend_from_slice(&payload);
Ok(buf)
}
pub fn from_binary(data: &[u8]) -> Result<Self, ModelBinaryError> {
if data.len() < MODEL_HEADER_SIZE {
return Err(ModelBinaryError::TooShort(data.len()));
}
if &data[0..4] != MODEL_MAGIC {
return Err(ModelBinaryError::BadMagic);
}
let version = data[4];
if version != MODEL_VERSION {
return Err(ModelBinaryError::UnsupportedVersion(version));
}
let format = data[5];
if format != FORMAT_POSTCARD {
return Err(ModelBinaryError::UnsupportedFormat(format));
}
let payload_len = u32::from_le_bytes([data[8], data[9], data[10], data[11]]) as usize;
let expected_total = MODEL_HEADER_SIZE + payload_len;
if data.len() < expected_total {
return Err(ModelBinaryError::TooShort(data.len()));
}
let stored_checksum: [u8; 32] = data[12..44].try_into().unwrap_or([0u8; 32]);
let payload = &data[MODEL_HEADER_SIZE..expected_total];
let computed = blake3::hash(payload);
if computed.as_bytes() != &stored_checksum {
return Err(ModelBinaryError::ChecksumMismatch);
}
let mlp: Self =
postcard::from_bytes(payload).map_err(|e| ModelBinaryError::Decode(e.to_string()))?;
Ok(mlp)
}
pub fn from_auto(data: &[u8]) -> Result<Self, ModelBinaryError> {
if data.len() >= 4 && &data[0..4] == MODEL_MAGIC {
Self::from_binary(data)
} else {
let json_str =
std::str::from_utf8(data).map_err(|e| ModelBinaryError::Decode(e.to_string()))?;
Self::from_json(json_str).map_err(|e| ModelBinaryError::Decode(e.to_string()))
}
}
}