clm-kernel 0.0.24

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use clm_rust_core::layer0::mcard_record::MCardRecord;
use clm_rust_core::layer2::{record_sqlite_guard, record_store};
use rusqlite::{params, Connection};

fn guarded() -> Connection {
    let conn = Connection::open_in_memory().unwrap();
    conn.execute_batch(clm_rust_core::db::CANONICAL_SCHEMA).unwrap();
    record_sqlite_guard::install(&conn).unwrap();
    conn
}

#[test]
fn duplicate_replace_preserves_original_coordinate() {
    let conn = guarded();
    let original = MCardRecord::create_at(b"stable", Some("sha256"), Some("2026-01-01T00:00:00Z"), "UTC").unwrap();
    let later = MCardRecord::create_at(b"stable", Some("sha256"), Some("2026-02-01T00:00:00Z"), "UTC").unwrap();
    record_store::insert_record(&conn, &original).unwrap();
    conn.execute("INSERT OR REPLACE INTO card VALUES (?1, ?2, ?3)", params![later.hash, later.content, later.g_time]).unwrap();
    assert_eq!(record_store::read_record(&conn, &original.hash).unwrap(), Some(original));
}

#[test]
fn direct_sql_rejects_invalid_rows_and_protected_schema_changes() {
    let conn = guarded();
    let record = MCardRecord::create(b"exact bytes", None).unwrap();
    record_store::insert_record(&conn, &record).unwrap();
    for policy in ["", "OR IGNORE", "OR REPLACE"] {
        assert!(conn.execute(&format!("INSERT {policy} INTO card VALUES (?1, ?2, ?3)"),
            params![record.hash, b"changed", record.g_time]).is_err());
    }
    for sql in [
        "UPDATE card SET content = 'changed'", "UPDATE card SET g_time = '2026-01-01T00:00:00Z'",
        "DROP TRIGGER temp.clm_card_insert", "DROP TABLE card", "ALTER TABLE card RENAME TO unchecked",
        "CREATE TEMP TABLE card(hash,content,g_time)", "CREATE TEMP VIEW card AS SELECT 1",
        "ATTACH DATABASE ':memory:' AS alternate", "PRAGMA writable_schema=ON", "PRAGMA recursive_triggers=OFF",
    ] { assert!(conn.execute_batch(sql).is_err(), "accepted bypass: {sql}"); }
    assert!(conn.execute("INSERT INTO handle_registry VALUES ('bad', 'missing', 'now')", []).is_err());
    assert!(conn.execute("INSERT INTO handle_registry VALUES ('bad', ?1, 'now')", [format!("sha512:{}", record.hash)]).is_err());
    assert_eq!(record_store::read_record(&conn, &record.hash).unwrap(), Some(record));
}

#[test]
fn corrupt_duplicates_and_existing_mutation_triggers_cannot_pass() {
    let conn = Connection::open_in_memory().unwrap();
    conn.execute_batch(clm_rust_core::db::CANONICAL_SCHEMA).unwrap();
    let record = MCardRecord::create(b"exact bytes", None).unwrap();
    conn.execute("INSERT INTO card VALUES (?1, ?2, ?3)", params![record.hash, b"corrupt", record.g_time]).unwrap();
    record_sqlite_guard::install(&conn).unwrap();
    for policy in ["OR IGNORE", "OR REPLACE"] {
        assert!(conn.execute(&format!("INSERT {policy} INTO card VALUES (?1, ?2, ?3)"),
            params![record.hash, record.content, record.g_time]).is_err());
    }
    let conn = Connection::open_in_memory().unwrap();
    conn.execute_batch(clm_rust_core::db::CANONICAL_SCHEMA).unwrap();
    conn.execute_batch("CREATE TRIGGER mutate_after_insert AFTER INSERT ON card BEGIN UPDATE card SET content='corrupt' WHERE hash=NEW.hash; END").unwrap();
    record_sqlite_guard::install(&conn).unwrap();
    assert!(record_store::insert_record(&conn, &record).is_err());
    assert_eq!(conn.query_row("SELECT count(*) FROM card", [], |r| r.get::<_, i64>(0)).unwrap(), 0);
}

#[test]
fn sdk_connection_rejects_temp_store_reset_and_keeps_guards_active() {
    let dir = tempfile::tempdir().unwrap();
    let conn = clm_rust_core::db::get_connection("content_memory", dir.path().to_str().unwrap()).unwrap();
    for sql in ["PRAGMA temp_store=MEMORY", "PRAGMA TeMp_StOrE=2", "PRAGMA temp_store_directory='/tmp'"] {
        assert!(conn.execute_batch(sql).is_err(), "accepted {sql}");
        assert!(conn.execute("INSERT INTO card VALUES ('fake', 'payload', '2026-01-01T00:00:00Z')", []).is_err());
    }
    let record = MCardRecord::create(b"after denied reset", None).unwrap();
    record_store::insert_record(&conn, &record).unwrap();
}