clm-kernel 0.0.23

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation

clm-kernel (0.0.23, Rust crate clm_rust_core)

clm-kernel (library target clm_rust_core) is the Rust 2024 microkernel for the Cubical Logic Model (CLM). It implements content-addressed MCard storage, BLAKE3 g_time provenance, bitset PlaceTypeLattice inference, Colored Petri Net execution, Cellular Sheaf Cohomology, and PyO3 acceleration bindings.

Cargo features

Cargo.toml defines composable feature flags so downstream crates and WebAssembly targets compile only the layers they need:

  • core: Minimal zero-network, zero-database core (BLAKE3 hashing, MCard/PCard/VCard, TypeLattice, PlaceTypeLattice, ColoredPetriVM, Open Petri Pullback, Sheaf Cohomology, and bialgebraic bisimulation). Compiles cleanly for wasm32-unknown-unknown with --no-default-features --features core.
  • fiber: Cordis Fiber context isolation, DisposableList, and SavepointGuard.
  • crdt: Vector clocks, G-Set handle history, and SyncContract v1 state convergence.
  • db: Dual-pool SQLite storage (rusqlite WAL mode, statement cache, and SqlSavepointPool).
  • bundled-sqlite: Compiles SQLite from source alongside db.
  • async: Tokio asynchronous task runtime.
  • net: QUIC (quinn) and mDNS (mdns-sd) Satori mesh transport.
  • native (default): Enables core, crdt, fiber, db, async, and net.
  • full: Alias for the complete native profile.
  • python: PyO3 extension bindings (clm_rust_core native module for clm_py_core).

Usage

Add clm-kernel 0.0.23 to Cargo.toml (the library crate name is clm_rust_core):

[dependencies]
clm-kernel = { version = "0.0.23", default-features = false, features = ["core", "fiber"] }

For wasm32-unknown-unknown builds, enable only core:

cargo check --target wasm32-unknown-unknown --no-default-features --features core

Quick start

use clm_rust_core::prelude::*;

fn main() -> Result<()> {
    let hash = raw_hash_bytes(b"hello clm 0.0.21");
    println!("BLAKE3 digest: {}", hash);

    let did = AgentDid::parse("did:pkc:node-1")?;
    println!("Agent DID: {}", did.as_str());
    Ok(())
}

Contract parameters

clm_rust_core::layer0::parameter_context::ParameterContext holds the contract's typed parameters, generated from the CLM runtime contract alongside the layer0::vocabulary* constant modules. from_mapping resolves CLI (contract keys) over environment (CLM_* names) over the contract default and returns ParameterBoundaryError for a value outside its refinement:

use std::collections::BTreeMap;
use clm_rust_core::layer0::parameter_context::ParameterContext;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let env = BTreeMap::from([("CLM_SQLITE_BUSY_TIMEOUT_MS".to_string(), "8000".to_string())]);
    let context = ParameterContext::from_mapping(&env, &BTreeMap::new())?;
    assert_eq!(context.sqlite_busy_timeout_ms, 8000);
    Ok(())
}

Production dispatch matches canonical catalog ids (evaluator::dispatch::catalog_ids::OP_*, resolved from module paths and operation names by op_id_for); an id with no handler is DispatchError::Unbound, raised before any receipt or store write.

CLI binaries

Building with default (native) features produces two binaries:

  • clm_rust_core: Full clmEval CLI evaluator, conformance runner, and formal oracle dispatcher.
  • clm_version_cli: Zero-framework fast version binary dispatched by ./clmEval version.
cargo run --release --bin clm_rust_core -- version --json

License

MIT License. Source code, formal proofs, and Python and TypeScript kernels live in the CLM repository.