xlog_logic/resolver/

manifest.rs

use std::collections::{BTreeMap, BTreeSet};
use std::fmt;
use std::path::{Component, Path, PathBuf};

use serde::Serialize;
use sha2::{Digest, Sha256};

use crate::ast::Program;
use crate::incremental_parse::{ParserSession, StatementSpan};
use crate::module::LoadedModule;
use crate::parser::parse_program;

use super::ModuleResolver;

const MANIFEST_SCHEMA_VERSION: &str = "xlog.resolved-program-manifest.v1";
const MODULE_ID_DOMAIN: &[u8] = b"xlog.resolved-module.v1\0";

/// A deterministic, content-addressed inventory of one resolved XLOG program.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ResolvedProgramManifest {
    /// Version of the machine-readable manifest contract.
    pub schema_version: String,
    /// Content-addressed identifier of the compilation entry module.
    pub entry_module_id: String,
    /// Complete entrypoint and transitive-import closure, sorted by source path.
    pub modules: Vec<ResolvedModuleManifest>,
    /// Import edges in deterministic importer and authored declaration order.
    pub imports: Vec<ResolvedImportManifest>,
    /// Complete source-object counts, sorted by construct kind.
    pub construct_inventory: Vec<ResolvedConstructCount>,
}

/// One source file in a resolved program closure.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ResolvedModuleManifest {
    /// Identifier derived from the source-root-relative path and exact bytes.
    pub module_id: String,
    /// UTF-8 source-root-relative path with `/` separators.
    pub source_path: String,
    /// SHA-256 of the exact UTF-8 bytes parsed by the resolver.
    pub content_sha256: String,
    /// Logical paths that reach this source from the current entry closure.
    pub logical_paths: Vec<String>,
    /// Source objects in authored statement order.
    pub source_objects: Vec<ResolvedSourceObject>,
}

/// One resolved import edge.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ResolvedImportManifest {
    /// Module containing the authored `use` declaration.
    pub importer_module_id: String,
    /// Module selected by importer-scoped resolution.
    pub target_module_id: String,
    /// Zero-based authored import ordinal in the importer.
    pub authored_ordinal: usize,
    /// Source object that owns this edge.
    pub source_object_id: String,
    /// Path as written by the importer.
    pub declared_path: Vec<String>,
    /// Contextual logical path selected by the resolver.
    pub resolved_path: Vec<String>,
    /// Explicitly selected public items, or `None` for the complete public surface.
    pub imported_items: Option<Vec<String>>,
}

/// One parsed source object and its exact authored source location.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ResolvedSourceObject {
    /// Stable identity within the content-addressed module.
    pub object_id: String,
    /// Parsed construct category.
    pub kind: ResolvedSourceObjectKind,
    /// Whether the object was authored or generated by a compiler transform.
    pub provenance: ResolvedSourceObjectProvenance,
    /// Zero-based order among all objects in the module.
    pub authored_ordinal: usize,
    /// Zero-based order among objects of the same kind in the module.
    pub kind_ordinal: usize,
    /// Zero-based order of the source statement containing this object.
    pub statement_ordinal: usize,
    /// SHA-256 of the exact statement bytes.
    pub content_sha256: String,
    /// Parser-owned byte and line/column span.
    pub span: ResolvedSourceSpan,
    /// Primary declared or head name when the construct has one.
    pub primary_name: Option<String>,
    /// Declared or head arity when the construct has one.
    pub arity: Option<usize>,
}

/// Origin of a source object exposed by the resolved-program inventory.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ResolvedSourceObjectProvenance {
    /// The object came directly from a parser-owned source statement.
    Authored,
}

/// Parser-owned source span copied into the stable manifest contract.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub struct ResolvedSourceSpan {
    /// Zero-based byte offset where the statement starts.
    pub start: usize,
    /// Exclusive zero-based byte offset where the statement ends.
    pub end: usize,
    /// One-based line where the statement starts.
    pub line: usize,
    /// One-based column where the statement starts.
    pub column: usize,
}

impl From<StatementSpan> for ResolvedSourceSpan {
    fn from(span: StatementSpan) -> Self {
        Self {
            start: span.start,
            end: span.end,
            line: span.line,
            column: span.column,
        }
    }
}

/// Source-level constructs represented by the canonical parser.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum ResolvedSourceObjectKind {
    /// A `use` declaration.
    Import,
    /// A user-defined function declaration.
    Function,
    /// A scalar domain alias declaration.
    Domain,
    /// A predicate schema declaration.
    Predicate,
    /// A fact or rule clause.
    Rule,
    /// An integrity constraint.
    Constraint,
    /// A deterministic query.
    Query,
    /// A probabilistic fact.
    ProbabilisticFact,
    /// An annotated disjunction.
    AnnotatedDisjunction,
    /// A probabilistic evidence statement.
    Evidence,
    /// A probabilistic query.
    ProbabilisticQuery,
    /// A neural predicate declaration.
    NeuralPredicate,
    /// A learnable rule template.
    LearnableRule,
    /// A compilation directive.
    Directive,
}

impl ResolvedSourceObjectKind {
    fn as_str(self) -> &'static str {
        match self {
            Self::Import => "import",
            Self::Function => "function",
            Self::Domain => "domain",
            Self::Predicate => "predicate",
            Self::Rule => "rule",
            Self::Constraint => "constraint",
            Self::Query => "query",
            Self::ProbabilisticFact => "probabilistic_fact",
            Self::AnnotatedDisjunction => "annotated_disjunction",
            Self::Evidence => "evidence",
            Self::ProbabilisticQuery => "probabilistic_query",
            Self::NeuralPredicate => "neural_predicate",
            Self::LearnableRule => "learnable_rule",
            Self::Directive => "directive",
        }
    }
}

/// Total number of source objects of one construct kind.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct ResolvedConstructCount {
    /// Counted source-object kind.
    pub kind: ResolvedSourceObjectKind,
    /// Number of objects of this kind in the complete closure.
    pub count: usize,
}

/// Fail-closed errors produced while binding a resolved closure to a source root.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ResolvedProgramManifestError {
    /// The resolver was not loaded from an exact entry file.
    MissingEntry,
    /// The resolved import surface is not valid under execution-time merge rules.
    ModuleValidation {
        /// Canonical module-resolution diagnostic.
        message: String,
    },
    /// The declared source root is missing, inaccessible, or not a directory.
    SourceRoot {
        /// Supplied source-root path.
        path: PathBuf,
        /// Filesystem error detail.
        message: String,
    },
    /// A resolved source escapes the declared source root.
    SourceOutsideRoot {
        /// Canonical source path outside the root.
        path: PathBuf,
        /// Canonical declared source root.
        source_root: PathBuf,
    },
    /// A relative source path cannot be represented in the JSON contract.
    NonUtf8Path {
        /// Source path containing non-UTF-8 components.
        path: PathBuf,
    },
    /// The resolver lacks the exact source text used for a loaded AST.
    MissingSourceText {
        /// Canonical source path whose parsed text is absent.
        path: PathBuf,
    },
    /// A module in the current closure has no current-entry logical path.
    MissingLogicalPath {
        /// Canonical source path lacking a current logical path.
        path: PathBuf,
    },
    /// A parser-owned statement could not be classified by the canonical parser.
    StatementParse {
        /// Source-root-relative module path.
        source_path: String,
        /// Zero-based authored statement ordinal.
        statement_ordinal: usize,
        /// Canonical parser diagnostic.
        message: String,
    },
    /// A parser-owned statement span does not address bytes in the retained source.
    InvalidStatementSpan {
        /// Source-root-relative module path.
        source_path: String,
        /// Zero-based authored statement ordinal.
        statement_ordinal: usize,
        /// Reported inclusive start byte.
        start: usize,
        /// Reported exclusive end byte.
        end: usize,
        /// Length of the retained source in bytes.
        source_len: usize,
    },
    /// A parsed statement produced no source-level AST object.
    StatementWithoutObject {
        /// Source-root-relative module path.
        source_path: String,
        /// Zero-based authored statement ordinal.
        statement_ordinal: usize,
    },
    /// Authored imports, resolved edges, and import source objects disagree.
    ImportGraphMismatch {
        /// Source-root-relative importer path.
        source_path: String,
        /// Number of authored import declarations.
        declarations: usize,
        /// Number of importer-scoped resolved edges.
        resolved_edges: usize,
        /// Number of import source objects.
        import_objects: usize,
    },
    /// A resolved edge points outside the loaded reachable closure.
    MissingImportTarget {
        /// Canonical target path absent from the closure.
        path: PathBuf,
    },
}

impl fmt::Display for ResolvedProgramManifestError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::MissingEntry => write!(
                formatter,
                "resolved program manifest requires an entry file"
            ),
            Self::ModuleValidation { message } => {
                write!(formatter, "resolved program validation failed: {message}")
            }
            Self::SourceRoot { path, message } => write!(
                formatter,
                "invalid source root '{}': {message}",
                path.display()
            ),
            Self::SourceOutsideRoot { path, source_root } => write!(
                formatter,
                "resolved source '{}' is outside source root '{}'",
                path.display(),
                source_root.display()
            ),
            Self::NonUtf8Path { path } => {
                write!(
                    formatter,
                    "resolved source path is not UTF-8: '{}'",
                    path.display()
                )
            }
            Self::MissingSourceText { path } => write!(
                formatter,
                "resolver did not retain parsed source bytes for '{}'",
                path.display()
            ),
            Self::MissingLogicalPath { path } => write!(
                formatter,
                "resolved source has no logical path in the current entry closure: '{}'",
                path.display()
            ),
            Self::StatementParse {
                source_path,
                statement_ordinal,
                message,
            } => write!(
                formatter,
                "failed to classify statement {statement_ordinal} in '{source_path}': {message}"
            ),
            Self::InvalidStatementSpan {
                source_path,
                statement_ordinal,
                start,
                end,
                source_len,
            } => write!(
                formatter,
                "invalid byte span {start}..{end} for statement {statement_ordinal} in \
                 '{source_path}' (source length {source_len})"
            ),
            Self::StatementWithoutObject {
                source_path,
                statement_ordinal,
            } => write!(
                formatter,
                "statement {statement_ordinal} in '{source_path}' produced no source object"
            ),
            Self::ImportGraphMismatch {
                source_path,
                declarations,
                resolved_edges,
                import_objects,
            } => write!(
                formatter,
                "import graph mismatch in '{source_path}': {declarations} declarations, \
                 {resolved_edges} resolved edges, {import_objects} import objects"
            ),
            Self::MissingImportTarget { path } => write!(
                formatter,
                "resolved import target is absent from the manifest closure: '{}'",
                path.display()
            ),
        }
    }
}

impl std::error::Error for ResolvedProgramManifestError {}

#[derive(Clone)]
struct ModuleIdentity {
    module_id: String,
    source_path: String,
    content_sha256: String,
}

struct SourceModule<'a> {
    source: &'a PathBuf,
    module: &'a LoadedModule,
    source_text: &'a str,
    is_entry: bool,
}

#[derive(Debug)]
struct ObjectDescriptor {
    kind: ResolvedSourceObjectKind,
    primary_name: Option<String>,
    arity: Option<usize>,
}

impl ModuleResolver {
    /// Build a deterministic source inventory from the exact bytes parsed by this resolver.
    ///
    /// Every source must resolve beneath `source_root`. Paths in the result are relative
    /// and platform-independent, while module and statement identities bind those paths
    /// to SHA-256 digests of the parsed bytes.
    pub fn resolved_program_manifest(
        &self,
        source_root: &Path,
    ) -> Result<ResolvedProgramManifest, ResolvedProgramManifestError> {
        let source_root = std::fs::canonicalize(source_root).map_err(|error| {
            ResolvedProgramManifestError::SourceRoot {
                path: source_root.to_path_buf(),
                message: error.to_string(),
            }
        })?;
        if !source_root.is_dir() {
            return Err(ResolvedProgramManifestError::SourceRoot {
                path: source_root,
                message: "path is not a directory".to_string(),
            });
        }
        let entry = self
            .entry
            .as_ref()
            .ok_or(ResolvedProgramManifestError::MissingEntry)?;
        let entry_source = self
            .entry_source
            .as_ref()
            .ok_or(ResolvedProgramManifestError::MissingEntry)?;
        let entry_source_text = self.entry_source_text.as_deref().ok_or_else(|| {
            ResolvedProgramManifestError::MissingSourceText {
                path: entry_source.clone(),
            }
        })?;
        self.merge_imports(entry.program.clone()).map_err(|error| {
            ResolvedProgramManifestError::ModuleValidation {
                message: error.to_string(),
            }
        })?;

        let mut reachable_sources = BTreeSet::new();
        let mut pending_sources = self
            .entry_resolved_imports
            .iter()
            .map(|edge| edge.source.clone())
            .collect::<Vec<_>>();
        while let Some(source) = pending_sources.pop() {
            if !reachable_sources.insert(source.clone()) {
                continue;
            }
            if let Some(edges) = self.resolved_imports.get(&source) {
                pending_sources.extend(edges.iter().map(|edge| edge.source.clone()));
            }
        }

        let mut source_modules = vec![SourceModule {
            source: entry_source,
            module: entry,
            source_text: entry_source_text,
            is_entry: true,
        }];
        for source in &reachable_sources {
            let module = self.loaded.get(source).ok_or_else(|| {
                ResolvedProgramManifestError::MissingImportTarget {
                    path: source.clone(),
                }
            })?;
            let source_text = self.loaded_source_texts.get(source).ok_or_else(|| {
                ResolvedProgramManifestError::MissingSourceText {
                    path: source.clone(),
                }
            })?;
            source_modules.push(SourceModule {
                source,
                module,
                source_text,
                is_entry: false,
            });
        }

        let mut identities = BTreeMap::new();
        for source_module in &source_modules {
            let source_path = relative_source_path(&source_root, source_module.source)?;
            let content_sha256 = sha256_prefixed(source_module.source_text.as_bytes());
            let module_id = module_id(&source_path, &content_sha256);
            identities.insert(
                source_module.source.clone(),
                ModuleIdentity {
                    module_id,
                    source_path,
                    content_sha256,
                },
            );
        }
        source_modules.sort_by(|left, right| {
            identities[left.source]
                .source_path
                .cmp(&identities[right.source].source_path)
        });

        let mut logical_paths_by_source = BTreeMap::<PathBuf, BTreeSet<String>>::new();
        logical_paths_by_source
            .entry(entry_source.clone())
            .or_default()
            .insert(entry.path.join("/"));
        for edge in &self.entry_resolved_imports {
            logical_paths_by_source
                .entry(edge.source.clone())
                .or_default()
                .insert(edge.module_path.join("/"));
        }
        for source in &reachable_sources {
            if let Some(edges) = self.resolved_imports.get(source) {
                for edge in edges {
                    logical_paths_by_source
                        .entry(edge.source.clone())
                        .or_default()
                        .insert(edge.module_path.join("/"));
                }
            }
        }

        let entry_module_id = identities[entry_source].module_id.clone();
        let mut modules = Vec::with_capacity(source_modules.len());
        for source_module in &source_modules {
            let identity = &identities[source_module.source];
            let logical_paths = logical_paths_by_source
                .get(source_module.source)
                .ok_or_else(|| ResolvedProgramManifestError::MissingLogicalPath {
                    path: source_module.source.clone(),
                })?;
            modules.push(ResolvedModuleManifest {
                module_id: identity.module_id.clone(),
                source_path: identity.source_path.clone(),
                content_sha256: identity.content_sha256.clone(),
                logical_paths: logical_paths.iter().cloned().collect(),
                source_objects: build_source_objects(
                    &identity.module_id,
                    &identity.source_path,
                    source_module.source_text,
                )?,
            });
        }

        let module_by_id = modules
            .iter()
            .map(|module| (module.module_id.clone(), module))
            .collect::<BTreeMap<_, _>>();
        let mut imports = Vec::new();
        for source_module in &source_modules {
            let identity = &identities[source_module.source];
            let resolved_edges = if source_module.is_entry {
                self.entry_resolved_imports.as_slice()
            } else {
                self.resolved_imports
                    .get(source_module.source)
                    .map(Vec::as_slice)
                    .unwrap_or_default()
            };
            let import_objects = module_by_id[&identity.module_id]
                .source_objects
                .iter()
                .filter(|object| object.kind == ResolvedSourceObjectKind::Import)
                .collect::<Vec<_>>();
            if source_module.module.program.imports.len() != resolved_edges.len()
                || resolved_edges.len() != import_objects.len()
            {
                return Err(ResolvedProgramManifestError::ImportGraphMismatch {
                    source_path: identity.source_path.clone(),
                    declarations: source_module.module.program.imports.len(),
                    resolved_edges: resolved_edges.len(),
                    import_objects: import_objects.len(),
                });
            }
            for (authored_ordinal, ((declaration, edge), source_object)) in source_module
                .module
                .program
                .imports
                .iter()
                .zip(resolved_edges)
                .zip(import_objects)
                .enumerate()
            {
                let target = identities.get(&edge.source).ok_or_else(|| {
                    ResolvedProgramManifestError::MissingImportTarget {
                        path: edge.source.clone(),
                    }
                })?;
                imports.push(ResolvedImportManifest {
                    importer_module_id: identity.module_id.clone(),
                    target_module_id: target.module_id.clone(),
                    authored_ordinal,
                    source_object_id: source_object.object_id.clone(),
                    declared_path: declaration.module_path.clone(),
                    resolved_path: edge.module_path.clone(),
                    imported_items: declaration.imports.clone(),
                });
            }
        }

        let mut inventory = BTreeMap::new();
        for object in modules.iter().flat_map(|module| &module.source_objects) {
            *inventory.entry(object.kind).or_insert(0usize) += 1;
        }

        Ok(ResolvedProgramManifest {
            schema_version: MANIFEST_SCHEMA_VERSION.to_string(),
            entry_module_id,
            modules,
            imports,
            construct_inventory: inventory
                .into_iter()
                .map(|(kind, count)| ResolvedConstructCount { kind, count })
                .collect(),
        })
    }
}

fn relative_source_path(
    source_root: &Path,
    source: &Path,
) -> Result<String, ResolvedProgramManifestError> {
    let relative = source.strip_prefix(source_root).map_err(|_| {
        ResolvedProgramManifestError::SourceOutsideRoot {
            path: source.to_path_buf(),
            source_root: source_root.to_path_buf(),
        }
    })?;
    let mut parts = Vec::new();
    for component in relative.components() {
        match component {
            Component::Normal(part) => parts.push(
                part.to_str()
                    .ok_or_else(|| ResolvedProgramManifestError::NonUtf8Path {
                        path: source.to_path_buf(),
                    })?
                    .to_string(),
            ),
            Component::CurDir => {}
            _ => {
                return Err(ResolvedProgramManifestError::SourceOutsideRoot {
                    path: source.to_path_buf(),
                    source_root: source_root.to_path_buf(),
                });
            }
        }
    }
    if parts.is_empty() {
        return Err(ResolvedProgramManifestError::NonUtf8Path {
            path: source.to_path_buf(),
        });
    }
    Ok(parts.join("/"))
}

fn module_id(source_path: &str, content_sha256: &str) -> String {
    let mut digest = Sha256::new();
    digest.update(MODULE_ID_DOMAIN);
    digest.update((source_path.len() as u64).to_le_bytes());
    digest.update(source_path.as_bytes());
    digest.update((content_sha256.len() as u64).to_le_bytes());
    digest.update(content_sha256.as_bytes());
    format!("sha256:{}", hex_digest(digest.finalize()))
}

fn build_source_objects(
    module_id: &str,
    source_path: &str,
    source_text: &str,
) -> Result<Vec<ResolvedSourceObject>, ResolvedProgramManifestError> {
    let mut objects = Vec::new();
    let mut kind_ordinals = BTreeMap::new();
    for (statement_ordinal, statement) in ParserSession::split_statements(source_text)
        .into_iter()
        .enumerate()
    {
        let parsed = parse_program(&statement.text).map_err(|error| {
            ResolvedProgramManifestError::StatementParse {
                source_path: source_path.to_string(),
                statement_ordinal,
                message: error.to_string(),
            }
        })?;
        let descriptors = describe_objects(&parsed);
        if descriptors.is_empty() {
            return Err(ResolvedProgramManifestError::StatementWithoutObject {
                source_path: source_path.to_string(),
                statement_ordinal,
            });
        }
        let span = statement.span;
        let source_bytes = source_text.as_bytes();
        if span.start > span.end || span.end > source_bytes.len() {
            return Err(ResolvedProgramManifestError::InvalidStatementSpan {
                source_path: source_path.to_string(),
                statement_ordinal,
                start: span.start,
                end: span.end,
                source_len: source_bytes.len(),
            });
        }
        let content_sha256 = sha256_prefixed(&source_bytes[span.start..span.end]);
        for descriptor in descriptors {
            let kind_ordinal = kind_ordinals.entry(descriptor.kind).or_insert(0usize);
            let object_id = format!("{module_id}#{}:{}", descriptor.kind.as_str(), *kind_ordinal);
            objects.push(ResolvedSourceObject {
                object_id,
                kind: descriptor.kind,
                provenance: ResolvedSourceObjectProvenance::Authored,
                authored_ordinal: objects.len(),
                kind_ordinal: *kind_ordinal,
                statement_ordinal,
                content_sha256: content_sha256.clone(),
                span: span.into(),
                primary_name: descriptor.primary_name,
                arity: descriptor.arity,
            });
            *kind_ordinal += 1;
        }
    }
    Ok(objects)
}

fn describe_objects(program: &Program) -> Vec<ObjectDescriptor> {
    let mut objects = Vec::new();
    objects.extend(program.imports.iter().map(|declaration| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Import,
        primary_name: Some(declaration.module_path.join("/")),
        arity: None,
    }));
    objects.extend(program.functions.iter().map(|definition| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Function,
        primary_name: Some(definition.name.clone()),
        arity: Some(definition.params.len()),
    }));
    objects.extend(program.domains.iter().map(|declaration| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Domain,
        primary_name: Some(declaration.name.clone()),
        arity: None,
    }));
    objects.extend(
        program
            .predicates
            .iter()
            .map(|declaration| ObjectDescriptor {
                kind: ResolvedSourceObjectKind::Predicate,
                primary_name: Some(declaration.name.clone()),
                arity: Some(declaration.schema_columns().len()),
            }),
    );
    objects.extend(program.rules.iter().map(|rule| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Rule,
        primary_name: Some(rule.head.predicate.clone()),
        arity: Some(rule.head.terms.len()),
    }));
    objects.extend(program.constraints.iter().map(|_| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Constraint,
        primary_name: None,
        arity: None,
    }));
    objects.extend(program.queries.iter().map(|query| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Query,
        primary_name: Some(query.atom.predicate.clone()),
        arity: Some(query.atom.terms.len()),
    }));
    objects.extend(program.prob_facts.iter().map(|fact| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::ProbabilisticFact,
        primary_name: Some(fact.atom.predicate.clone()),
        arity: Some(fact.atom.terms.len()),
    }));
    objects.extend(
        program
            .annotated_disjunctions
            .iter()
            .map(|_| ObjectDescriptor {
                kind: ResolvedSourceObjectKind::AnnotatedDisjunction,
                primary_name: None,
                arity: None,
            }),
    );
    objects.extend(program.evidence.iter().map(|evidence| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::Evidence,
        primary_name: Some(evidence.atom.predicate.clone()),
        arity: Some(evidence.atom.terms.len()),
    }));
    objects.extend(program.prob_queries.iter().map(|query| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::ProbabilisticQuery,
        primary_name: Some(query.atom.predicate.clone()),
        arity: Some(query.atom.terms.len()),
    }));
    objects.extend(
        program
            .neural_predicates
            .iter()
            .map(|declaration| ObjectDescriptor {
                kind: ResolvedSourceObjectKind::NeuralPredicate,
                primary_name: Some(declaration.predicate.predicate.clone()),
                arity: Some(declaration.predicate.terms.len()),
            }),
    );
    objects.extend(program.learnable_rules.iter().map(|rule| ObjectDescriptor {
        kind: ResolvedSourceObjectKind::LearnableRule,
        primary_name: Some(rule.head.predicate.clone()),
        arity: Some(rule.head.terms.len()),
    }));
    objects.extend(
        program
            .directives
            .set_pragma_names()
            .into_iter()
            .map(|name| ObjectDescriptor {
                kind: ResolvedSourceObjectKind::Directive,
                primary_name: Some(name.to_string()),
                arity: None,
            }),
    );
    objects
}

fn sha256_prefixed(bytes: &[u8]) -> String {
    let mut digest = Sha256::new();
    digest.update(bytes);
    format!("sha256:{}", hex_digest(digest.finalize()))
}

fn hex_digest(bytes: impl AsRef<[u8]>) -> String {
    let bytes = bytes.as_ref();
    let mut output = String::with_capacity(bytes.len() * 2);
    for byte in bytes {
        use std::fmt::Write as _;
        write!(&mut output, "{byte:02x}").expect("writing to String cannot fail");
    }
    output
}