Method apply_view_manifest

atomic-repository/src/repository/views.rs:889–1056

Declaratively apply a [`ViewManifest`]: create the view with its declared identity if absent, then fast-forward its change log to match the manifest. # Semantics Everything is validated **before** any write: 1. The manifest's declared state must equal the fold of its log. 2. Every referenced change file must be present in the local store. 3. Every dependency of every change must appear earlier

(
        &mut self,
        manifest: &ViewManifest,
    )

    /// resumes where it stopped. After replay the view's merkle state is
    /// verified against the declared state.
    pub fn apply_view_manifest(
        &mut self,
        manifest: &ViewManifest,
    ) -> Result<ManifestApplyOutcome, RepositoryError> {
        // 1. Structural integrity: declared state == fold of the log.
        manifest.verify()?;

        // 2. Presence: every change file must exist locally.
        let missing: Vec<&Hash> = manifest
            .changes
            .iter()
            .filter(|h| !self.has_change(h))
            .collect();
        if let Some(first) = missing.first() {
            return Err(RepositoryError::ManifestMissingChanges {
                view: manifest.name.clone(),
                count: missing.len(),
                first: first.to_base32(),
            });
        }

        // 3. Dependency closure: deps must be earlier in the log or already
        //    applied locally. Read from the change files (self-contained DAG).
        {
            let txn = self
                .pristine
                .read_txn()
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
            let mut seen: HashSet<Hash> = HashSet::with_capacity(manifest.changes.len());
            for hash in &manifest.changes {
                let change = self.load_change(hash)?;
                for dep in change.dependencies() {
                    if seen.contains(dep) {
                        continue;
                    }
                    let applied = txn
                        .get_internal(dep)
                        .map_err(|e| RepositoryError::Database(e.to_string()))?
                        .is_some();
                    if !applied {
                        return Err(RepositoryError::ManifestDependencyMissing {
                            view: manifest.name.clone(),
                            change: hash.to_base32(),
                            dependency: dep.to_base32(),
                        });
                    }
                }
                seen.insert(*hash);
            }
        }

        // 4. Identity + prefix rule against the existing view (if any).
        let prefix_len = {
            let txn = self
                .pristine
                .read_txn()
                .map_err(|e| RepositoryError::Database(e.to_string()))?;
            match txn