verit-core 0.1.0

//! # Veritate
//!
//! One serialization format that is actually all three things at once:
//!
//! - **Zero-copy**: every field read is a bounds-checked indexed load straight
//!   from the message buffer. Strings and bytes come back as `&str` / `&[u8]`
//!   borrowing the buffer. No parse step, no allocation on the read path.
//! - **Self-describing**: every message carries the 128-bit content hash of its
//!   writer schema, and can carry the full schema inline. A message plus
//!   nothing else is fully interpretable — see [`dump_json`].
//! - **Schema-evolvable**: fields are identified by stable numeric IDs.
//!   Readers resolve (writer schema, reader schema) once into a cached
//!   [`Resolver`] access plan; added fields read as `None` for old readers'
//!   data, unknown fields cost nothing, renames are free, integer widening is
//!   converted on load.
//!
//! The trick that resolves the classic pick-two trilemma: the indirection that
//! evolution needs is paid **once per schema pair**, not per message (protobuf
//! tags, JSON keys) and not at build time (FlatBuffers codegen). See the architecture docs
//! for the wire format.

// The library contains no `unsafe`, by design (memory safety on untrusted bytes
// rests on it) — enforced by the compiler, not just convention.
#![forbid(unsafe_code)]

pub mod codegen;
pub mod container;
pub mod derive;
pub mod dump;
pub mod encode;
pub mod error;
pub mod hash;
pub mod idl;
pub mod layout;
pub mod message;
pub mod registry;
pub mod resolve;
pub mod schema;
pub mod value;
pub mod wire;

pub use container::{Container, ContainerWriter};
pub use derive::VeritType;
pub use dump::dump_json;
pub use encode::{encode, SchemaMode};
pub use error::{Error, Result};
pub use message::{Budget, ListReader, Message, Ref, StructReader};
pub use registry::SchemaRegistry;
pub use resolve::Resolver;
pub use schema::{
    Default, Dt, EnumDef, FieldDef, Schema, SchemaBuilder, StructDef, StructMode, Type, TypeDef,
};
pub use value::Value;