kmp-application 0.18.0

Application services behind KMP's ten memory moves and evidence-backed recall
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! Resolve the semantic writer's implicit observation at the ingestion boundary.
//! Canonical ingest opts in explicitly; replay digests use the unresolved command.

use super::MemoryIngestCommand;

pub(super) fn resolve(command: &MemoryIngestCommand, ingested_at: &str) -> MemoryIngestCommand {
    let mut resolved = command.clone();
    if let Some(provenance) = &mut resolved.provenance {
        provenance
            .observed_at
            .get_or_insert_with(|| ingested_at.to_owned());
    }
    for coordinate in resolved
        .memory
        .entries
        .iter_mut()
        .flat_map(|entry| &mut entry.coordinates)
        .chain(
            resolved
                .memory
                .relations
                .iter_mut()
                .filter(|relation| relation.semantic_class.trim() == "structural")
                .filter_map(|relation| relation.coordinate.as_mut()),
        )
    {
        // Search-summary updates carry already stored coordinates. An unknown
        // historical observation remains unknown, even if this write is new.
        if coordinate.ingested_at.is_none() {
            coordinate
                .observed_at
                .get_or_insert_with(|| ingested_at.to_owned());
        }
    }
    for evidence in &mut resolved.memory.evidence {
        evidence.time.get_or_insert_with(|| ingested_at.to_owned());
        if let Some(clocks) = &mut evidence.support_clocks
            && clocks.ingested_at.is_none()
        {
            clocks
                .observed_at
                .get_or_insert_with(|| ingested_at.to_owned());
        }
    }
    // Explicit proof clock objects carry the semantic member's own declaration.
    // Absence still uses canonical packet inheritance in namespaced_memory.
    // Restored clocks, including unknown historical observations, stay intact.
    for clocks in resolved
        .memory
        .relations
        .iter_mut()
        .filter(|relation| relation.semantic_class.trim() != "structural")
        .filter(|relation| {
            !relation.coordinate.as_ref().is_some_and(|coordinate| {
                coordinate.observed_at.is_some() || coordinate.ingested_at.is_some()
            })
        })
        .filter_map(|relation| relation.clocks.as_mut())
        .filter(|clocks| clocks.ingested_at.is_none())
    {
        clocks
            .observed_at
            .get_or_insert_with(|| ingested_at.to_owned());
    }
    resolved
}