mere-kernel 0.0.3

Portable identity, authority, and mutation kernel for the Mere browser. Renamed from graphshell-core.
Documentation
// Copyright 2026 Mark Alan Boykin
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
// SPDX-License-Identifier: MPL-2.0

//! Import-record operations.
//!
//! Manages the durable `import_records` truth on `Graph`: queries,
//! membership suppression, replacement, and the projection of the table
//! onto per-node `NodeImportProvenance` facets
//! (`sync_node_import_provenance_from_records`).
//!
//! The table owns memberships and their suppression. The per-node facet
//! is a projection that omits suppressed memberships, so nothing here
//! rebuilds the table from it. `set_node_import_provenance` edits that
//! node's memberships in the table; a snapshot that predates the table
//! derives it from the legacy persisted column
//! (`import_records_from_legacy_provenance`).
//!
//! Extracted from `graph/mod.rs` per the 2026-05-11 kernel
//! decomposition pass.

use std::collections::{BTreeMap, HashMap};

use uuid::Uuid;

use super::identity::NodeKey;
use super::{Graph, current_unix_timestamp_secs, normalize_import_records};
use crate::types::{
    ImportRecord, ImportRecordMembership, NodeImportProvenance, NodeImportRecordSummary,
};

impl Graph {
    pub fn import_records(&self) -> &[ImportRecord] {
        &self.import_records
    }

    pub fn import_record_summaries_for_node(&self, key: NodeKey) -> Vec<NodeImportRecordSummary> {
        let Some(node) = self.get_node(key) else {
            return Vec::new();
        };
        let node_id = node.id.to_string();
        let mut summaries = self
            .import_records
            .iter()
            .filter(|record| {
                record
                    .memberships
                    .iter()
                    .any(|membership| membership.node_id == node_id && !membership.suppressed)
            })
            .map(|record| NodeImportRecordSummary {
                record_id: record.record_id.clone(),
                source_id: record.source_id.clone(),
                source_label: record.source_label.clone(),
                imported_at_secs: record.imported_at_secs,
            })
            .collect::<Vec<_>>();
        summaries.sort_by(|left, right| {
            right
                .imported_at_secs
                .cmp(&left.imported_at_secs)
                .then_with(|| left.source_label.cmp(&right.source_label))
                .then_with(|| left.record_id.cmp(&right.record_id))
        });
        summaries
    }

    pub fn import_record_member_keys(&self, record_id: &str) -> Vec<NodeKey> {
        let mut member_keys = self
            .import_records
            .iter()
            .find(|record| record.record_id == record_id)
            .into_iter()
            .flat_map(|record| record.memberships.iter())
            .filter(|membership| !membership.suppressed)
            .filter_map(|membership| Uuid::parse_str(&membership.node_id).ok())
            .filter_map(|node_id| self.inner.key_of(&node_id))
            .collect::<Vec<_>>();
        member_keys.sort_by_key(|key| key.index());
        member_keys.dedup();
        member_keys
    }

    pub(crate) fn delete_import_record(&mut self, record_id: &str) -> bool {
        let original_len = self.import_records.len();
        self.import_records
            .retain(|record| record.record_id != record_id);
        if self.import_records.len() == original_len {
            return false;
        }
        self.sync_node_import_provenance_from_records();
        true
    }

    pub(crate) fn set_import_record_membership_suppressed(
        &mut self,
        record_id: &str,
        key: NodeKey,
        suppressed: bool,
    ) -> bool {
        let Some(node_id) = self.get_node(key).map(|node| node.id.to_string()) else {
            return false;
        };
        let mut changed = false;
        for record in &mut self.import_records {
            if record.record_id != record_id {
                continue;
            }
            for membership in &mut record.memberships {
                if membership.node_id == node_id {
                    if membership.suppressed != suppressed {
                        membership.suppressed = suppressed;
                        changed = true;
                    }
                    break;
                }
            }
        }
        if changed {
            self.sync_node_import_provenance_from_records();
        }
        changed
    }

    pub(crate) fn set_import_records(&mut self, mut import_records: Vec<ImportRecord>) -> bool {
        normalize_import_records(&mut import_records);
        if self.import_records == import_records {
            return false;
        }
        self.import_records = import_records;
        self.sync_node_import_provenance_from_records();
        true
    }

    pub(crate) fn sync_node_import_provenance_from_records(&mut self) {
        let mut provenance_by_node = HashMap::<NodeKey, Vec<NodeImportProvenance>>::new();
        for record in &self.import_records {
            for membership in record
                .memberships
                .iter()
                .filter(|membership| !membership.suppressed)
            {
                let Ok(node_id) = Uuid::parse_str(&membership.node_id) else {
                    continue;
                };
                let Some(node_key) = self.inner.key_of(&node_id) else {
                    continue;
                };
                provenance_by_node
                    .entry(node_key)
                    .or_default()
                    .push(NodeImportProvenance {
                        source_id: record.source_id.clone(),
                        source_label: record.source_label.clone(),
                    });
            }
        }

        let node_keys = self.inner.inner().node_indices().collect::<Vec<_>>();
        for node_key in node_keys {
            let mut provenance = provenance_by_node.remove(&node_key).unwrap_or_default();
            provenance.sort();
            provenance.dedup();
            self.set_node_facet(node_key, super::node_facets::PROVENANCE_IMPORT, &provenance);
        }
    }

    /// Make `key`'s active provenance exactly `import_provenance`, touching
    /// only that node's memberships. Other nodes and every suppressed
    /// membership stay as the table has them.
    pub(crate) fn set_node_import_provenance(
        &mut self,
        key: NodeKey,
        import_provenance: Vec<NodeImportProvenance>,
    ) -> bool {
        let Some(node_id) = self.get_node(key).map(|node| node.id.to_string()) else {
            return false;
        };
        let mut wanted = import_provenance;
        wanted.sort();
        wanted.dedup();
        if active_provenance(&self.import_records, &node_id) == wanted {
            return false;
        }
        let mut records = std::mem::take(&mut self.import_records);
        assign_node_memberships(
            &mut records,
            &node_id,
            &wanted,
            current_unix_timestamp_secs(),
        );
        normalize_import_records(&mut records);
        self.import_records = records;
        let projected = active_provenance(&self.import_records, &node_id);
        self.set_node_facet(key, super::node_facets::PROVENANCE_IMPORT, &projected);
        true
    }
}

fn is_source(record: &ImportRecord, source: &NodeImportProvenance) -> bool {
    record.source_id == source.source_id && record.source_label == source.source_label
}

/// What the table projects onto a node: its unsuppressed memberships' sources.
fn active_provenance(records: &[ImportRecord], node_id: &str) -> Vec<NodeImportProvenance> {
    let mut provenance = records
        .iter()
        .filter(|record| {
            record
                .memberships
                .iter()
                .any(|membership| membership.node_id == node_id && !membership.suppressed)
        })
        .map(|record| NodeImportProvenance {
            source_id: record.source_id.clone(),
            source_label: record.source_label.clone(),
        })
        .collect::<Vec<_>>();
    provenance.sort();
    provenance.dedup();
    provenance
}

/// Edit `node_id`'s memberships so its active sources are exactly `wanted`.
/// A source the node lacks goes to the latest record of that source (an
/// existing membership is un-suppressed), or to a new record if none exists.
/// The node's suppressed memberships in other sources are left alone.
fn assign_node_memberships(
    records: &mut Vec<ImportRecord>,
    node_id: &str,
    wanted: &[NodeImportProvenance],
    imported_at_secs: u64,
) {
    for record in records.iter_mut() {
        if !wanted.iter().any(|source| is_source(record, source)) {
            record
                .memberships
                .retain(|membership| membership.node_id != node_id || membership.suppressed);
        }
    }
    records.retain(|record| !record.memberships.is_empty());
    let active = active_provenance(records, node_id);
    for source in wanted.iter().filter(|source| !active.contains(source)) {
        let Some(record) = records
            .iter_mut()
            .rev()
            .find(|record| is_source(record, source))
        else {
            records.push(ImportRecord {
                record_id: format!("import-record:{}", source.source_id),
                source_id: source.source_id.clone(),
                source_label: source.source_label.clone(),
                imported_at_secs,
                memberships: vec![ImportRecordMembership {
                    node_id: node_id.to_string(),
                    suppressed: false,
                }],
            });
            continue;
        };
        match record
            .memberships
            .iter_mut()
            .find(|membership| membership.node_id == node_id)
        {
            Some(membership) => membership.suppressed = false,
            None => record.memberships.push(ImportRecordMembership {
                node_id: node_id.to_string(),
                suppressed: false,
            }),
        }
    }
}

/// Import records for a snapshot that predates the table: only the legacy
/// per-node `import_provenance` column names the sources.
pub(crate) fn import_records_from_legacy_provenance<'a>(
    nodes: impl IntoIterator<Item = (Uuid, &'a [NodeImportProvenance])>,
    imported_at_secs: u64,
) -> Vec<ImportRecord> {
    let mut grouped = BTreeMap::<(String, String), Vec<ImportRecordMembership>>::new();
    for (node_id, provenance) in nodes {
        for source in provenance {
            grouped
                .entry((source.source_id.clone(), source.source_label.clone()))
                .or_default()
                .push(ImportRecordMembership {
                    node_id: node_id.to_string(),
                    suppressed: false,
                });
        }
    }
    grouped
        .into_iter()
        .map(|((source_id, source_label), memberships)| ImportRecord {
            record_id: format!("import-record:{source_id}"),
            source_id,
            source_label,
            imported_at_secs,
            memberships,
        })
        .collect()
}