khive-runtime 0.19.0

Composable Service API: entity/note CRUD, graph traversal, hybrid search, curation.
Documentation
const MODEL_KEYS: [&str; 4] = ["model.k0", "model.k1", "model.k2", "model.k3"];

#[derive(Clone, Copy, Debug)]
enum ModelOp {
    Observe(usize, usize),
    Drain(usize),
}

fn model_schedule(mut seed: u64) -> Vec<ModelOp> {
    use ModelOp::{Drain, Observe};
    let mut operations = vec![
        Observe(0, 0),
        Observe(1, 0),
        Observe(1, 1),
        Drain(0),
        Drain(0),
        Drain(1),
        Observe(0, 2),
        Observe(1, 3),
        Observe(1, 2),
        Drain(0),
        Drain(0),
        Drain(1),
    ];
    for _ in 0..240 {
        seed = seed
            .wrapping_mul(6_364_136_223_846_793_005)
            .wrapping_add(1_442_695_040_888_963_407);
        let choice = ((seed >> 32) % 10) as usize;
        operations.push(match choice {
            0..=3 => Observe(0, choice),
            4..=7 => Observe(1, choice - 4),
            8 => Drain(0),
            _ => Drain(1),
        });
    }
    operations.extend([Observe(0, 1), Observe(0, 3), Drain(0), Drain(1)]);
    operations
}

async fn run_model(seed: u64) {
    let backend = prepared_backend();
    let d = Fixture::from_runtime(
        runtime_on(backend.clone(), "model-d"),
        "local",
        "same-backend-model",
    );
    let e = Fixture::from_runtime(
        runtime_on(backend, "model-e"),
        "local",
        "same-backend-model",
    );
    let owners = [&d, &e];
    let mut seen = [[false; 4]; 2];
    let mut pending = [[false; 4]; 2];
    let mut delivered = [0usize; 4];
    let operations = model_schedule(seed);
    assert_eq!(
        operations.len(),
        256,
        "each fixed seed exercises at least 200 operations"
    );
    for (step, operation) in operations.iter().copied().enumerate() {
        match operation {
            ModelOp::Observe(owner, key) => {
                owners[owner]
                    .runtime
                    .record_config_locked(MODEL_KEYS[key], || "locked".into());
                if !seen[owner][key] {
                    seen[owner][key] = true;
                    pending[owner][key] = true;
                }
            }
            ModelOp::Drain(owner) => {
                owners[owner].dispatch().await;
                for (pending, delivered) in pending[owner].iter_mut().zip(&mut delivered) {
                    if *pending {
                        *delivered += 1;
                        *pending = false;
                    }
                }
                let rows = owners[owner].rows().await;
                assert!(
                    rows.iter()
                        .all(|row| row.namespace == "local"
                            && row.actor == "actor:same-backend-model"),
                    "same backend pair uses identical actual dispatch identity"
                );
                let actual = MODEL_KEYS
                    .map(|key| rows.iter().filter(|row| row.payload["key"] == key).count());
                assert_eq!(
                    actual,
                    delivered,
                    "seed={seed:#x}, zero-based step={step}, op={operation:?}, prefix={:?}",
                    &operations[..=step]
                );
                assert_eq!(
                    rows.len(),
                    delivered.iter().sum::<usize>(),
                    "no unrelated config rows"
                );
                assert!(rows.iter().all(|row| row.payload["value"] == "locked"));
                assert_eq!(
                    rows.iter().map(|row| row.id).collect::<BTreeSet<_>>().len(),
                    rows.len()
                );
            }
        }
    }
    assert_eq!(delivered, [2; 4]);
    for fixture in owners {
        for key in MODEL_KEYS {
            assert_eq!(
                fixture.store.submitted(key).len(),
                1,
                "one submission per owner and name"
            );
            fixture
                .runtime
                .record_config_locked(key, || panic!("model name already observed"));
        }
        fixture.dispatch().await;
        assert_eq!(fixture.rows().await.len(), 8);
        fixture.finish().await;
    }
}

#[tokio::test]
#[serial(config_ledger)]
async fn same_backend_model_seed_5901d3e320260001_matches_every_completed_drain() {
    run_model(0x5901_d3e3_2026_0001).await;
}

#[tokio::test]
#[serial(config_ledger)]
async fn same_backend_model_seed_5901d3e320260002_matches_every_completed_drain() {
    run_model(0x5901_d3e3_2026_0002).await;
}