MessagePack

use msgpack.qweruse msgpack_encode, msgpack_decode from msgpack      // Quillo 0.6: only these

rmp-serde = "1"rmpv = "1"base64 = "0.22"

// A cache of orders kept as MessagePack, smaller than JSON, and read back.////   quillo run msgpack.qwe      then open http://localhost:8080/sizesuse "msgpack.qwer"let orders = range(50) | map((i) => { id: i, customer: `customer-${i}`, total: 10.5 + i, paid: i % 2 == 0, items: [i, i + 1] })route GET /sizes {    let bytes = msgpack_write_file("data/orders.msgpack", orders)?    let back = msgpack_read_file("data/orders.msgpack")?    { msgpack_bytes: bytes, json_bytes: len(json.stringify(orders)), same: back == orders, third: back[2] }}route GET /roundtrip {    let packed = msgpack_encode({ event: "signup", user: 7, at: "2026-11-02T09:00:00Z", tags: ["beta"] })?    { packed, back: msgpack_decode(packed)? }}

//! MessagePack, the compact binary JSON: values to MessagePack (as base64 or a file) and back, for caches, queues and APIs that speak it.//! version: 1.0.0//!//! [dependencies]//! rmp-serde = "1"//! rmpv = "1"//! base64 = "0.22"use base64::engine::general_purpose::{STANDARD, URL_SAFE_NO_PAD};use base64::Engine;use serde_json::{json, Map, Value};/// At most 64 MiB of MessagePack is read or written.const MAX: usize = 64 * 1024 * 1024;fn to_json(v: rmpv::Value) -> Value {    use rmpv::Value as M;    match v {        M::Nil => Value::Null,        M::Boolean(b) => Value::Bool(b),        M::Integer(i) => i.as_i64().map(Value::from).or_else(|| i.as_u64().map(Value::from)).or_else(|| i.as_f64().map(Value::from)).unwrap_or(Value::Null),        M::F32(f) => json!(f as f64),        M::F64(f) => json!(f),        M::String(s) => Value::String(s.into_str().unwrap_or_default()),        // Bytes have no JSON form: they come back as base64 text.        M::Binary(b) => Value::String(STANDARD.encode(b)),        M::Array(a) => Value::Array(a.into_iter().map(to_json).collect()),        M::Map(m) => {            let mut out = Map::new();            for (k, v) in m {                let key = match k {                    M::String(s) => s.into_str().unwrap_or_default(),                    other => other.to_string(),                };                out.insert(key, to_json(v));            }            Value::Object(out)        }        M::Ext(t, data) => json!({ "ext_type": t, "data": STANDARD.encode(data) }),    }}fn encode(value: &Value) -> Result<Vec<u8>, String> {    let b = rmp_serde::to_vec_named(value).map_err(|e| e.to_string())?;    if b.len() > MAX { Err("MessagePack over 64 MiB".into()) } else { Ok(b) }}fn decode(bytes: &[u8]) -> Result<Value, String> {    if bytes.len() > MAX {        return Err("MessagePack over 64 MiB".into());    }    let mut r = bytes;    let v = rmpv::decode::read_value(&mut r).map_err(|e| format!("not MessagePack: {}", e))?;    Ok(to_json(v))}/// `value` as MessagePack, in base64: maps keep their keys' names, ints stay ints and floats floats.pub fn msgpack_encode(value: serde_json::Value) -> Result<String, String> {    Ok(STANDARD.encode(encode(&value)?))}/// The value in MessagePack given as base64 (standard or URL-safe). Binary fields come back as base64 text, extension/// types as `{ ext_type, data }`, and map keys that are not text as their text.pub fn msgpack_decode(base64_text: &str) -> Result<Value, String> {    let t = base64_text.trim();    let bytes = STANDARD.decode(t).or_else(|_| URL_SAFE_NO_PAD.decode(t.trim_end_matches('='))).map_err(|_| "not base64".to_string())?;    decode(&bytes)}/// Writes `value` as MessagePack to the file at `path` (folders made); gives the bytes written.pub fn msgpack_write_file(path: &str, value: serde_json::Value) -> Result<i64, String> {    let b = encode(&value)?;    if let Some(dir) = std::path::Path::new(path).parent() {        if !dir.as_os_str().is_empty() {            std::fs::create_dir_all(dir).map_err(|e| format!("{}: {}", dir.display(), e))?;        }    }    std::fs::write(path, &b).map_err(|e| format!("{}: {}", path, e))?;    Ok(b.len() as i64)}/// The value in a MessagePack file.pub fn msgpack_read_file(path: &str) -> Result<Value, String> {    let size = std::fs::metadata(path).map_err(|e| format!("{}: {}", path, e))?.len();    if size as usize > MAX {        return Err(format!("{}: over 64 MiB", path));    }    decode(&std::fs::read(path).map_err(|e| format!("{}: {}", path, e))?)}