Manifest as a flat binary file, hashes and graph keys as bytes (refs #41) 1966f5db15ee

        // The manifest after the checkout, built from what is known.

        let plan = crate::timing::phase("checkout: plan");

        let mut entries: BTreeMap<String, FsEntry> = BTreeMap::new();

        // Text files to render, attribute files first (the others need them).

        let mut texts: Vec<(String, NodeId, Mode)> = Vec::new();

        for (path, e) in tview.entries.iter() {

                // The manifest proves the file on disk equal to the rendering

                // of a graph whose key is the target's: nothing to read,

                // render or write.

                let proven = |m: &&prompt::ManifestEntry| {

                    !is_attributes(path) && key.is_some() && m.graph == key

                };

                        entries.insert(

                            path.clone(),

                            FsEntry {

                                unchanged: true,

                                stat: Some((m.size, m.mtime_ns)),

                                ..FsEntry::new(NodeKind::File, e.mode.exec, Vec::new())

                entries.insert(

                    path.clone(),

                    FsEntry {

                        blob: (e.kind == NodeKind::File).then_some(blob),

                        stat: Some((m.size, m.mtime_ns)),

                        ..FsEntry::new(e.kind, e.mode.exec, Vec::new())

                    FsEntry {

                        content_hash: Some(hex(&on_disk)),

                        graph_key: (!conflicted && a.eol.is_none())

                            .flatten(),

                        ..FsEntry::new(NodeKind::File, mode.exec, Vec::new())

                    },

}

/// A text file's base graph key, by path, as a walk asks for it.

/// A file as found on disk or in an imported tree.

pub(crate) struct FsEntry {

    pub blob: Option<ObjectRef>,

    /// BLAKE3 of the content, carried over from the manifest when the stat

    /// is unchanged, so the manifest can be rewritten without rehashing.

    /// A text file known equal to the base's rendering without reading it:

    /// its stat matches the manifest and the manifest recorded it equal to

    /// a base file graph with the same key (spec §12.3). `content` is empty.

    pub unchanged: bool,

    /// The base graph key this file equals, for the next manifest.

    /// Size and mtime already known to be current (a checkout leaving the

    /// file as it was), so the manifest need not stat it again.

    pub stat: Option<(u64, u128)>,

                            stat_cached(rel, meta, cache).is_some_and(|e| e.graph.is_some())

                        })

                        .and_then(|k| k(rel));

                })

                .collect::<Result<Vec<_>>>()?;

            for (rel, mut e) in read {

    path: &Path,

    meta: &fs::Metadata,

    cache: Option<&prompt::Manifest>,

) -> Result<FsEntry> {

    let exec = is_executable(meta);

    let stat = Some((meta.len(), prompt::mtime_ns(meta)));

    let mut e = match stat_cached(rel, meta, cache) {

        Some(e) if e.blob.is_some() => FsEntry {

            blob: e.blob,

            ..FsEntry::new(NodeKind::File, exec, vec![])

        },

            unchanged: true,

            ..FsEntry::new(NodeKind::File, exec, vec![])

        },

        Some(e) => FsEntry {

            ..FsEntry::new(NodeKind::File, exec, fs::read(path)?)

        },

        None => FsEntry::new(NodeKind::File, exec, fs::read(path)?),

pub(crate) struct ManifestEntry {

    pub size: u64,

    pub mtime_ns: u128,

    pub blob: Option<ObjectRef>,

    /// The graph key (`State::graph_key`) of the base file this text file

    /// was found equal to, rendered, byte for byte.

    /// Whether the file was executable: a mode change alters neither size

    /// nor time.

    pub exec: bool,

/// A format with glyphs: icon, bookmark, change id, state, ahead/behind.

pub const GLYPH_PROMPT_FORMAT: &str = "%i %b %c %s%U%O";

}

impl Repo {

    pub(crate) fn manifest_path(&self) -> PathBuf {

        self.oxy

            .duration_since(UNIX_EPOCH)

            .map(|d| d.as_nanos())

            .unwrap_or(0);

        let mut newest_ns: u128 = 0;

            let (size, mtime_ns) = match e.stat {

                Some(known) => known,

                    Ok(m) => (m.len(), mtime_ns(&m)),

                    Err(_) => (e.content.len() as u64, 0),

                },

            };

            newest_ns = newest_ns.max(mtime_ns);

                size,

                mtime_ns,

        let p = self.manifest_path();

        // Leave an unchanged manifest alone when its stamp already trusts

        // every entry (none is within the racy window): rewriting it would

        // change nothing but the file, which editors watching the tree

        // (and subrepos inside it) take as a change.

                    return Ok(());

                }

            }

        }

        fs::create_dir_all(p.parent().unwrap())?;

    }

    /// Change the header flags, and set the graph key of each path in

        &self,

        conflicted: bool,

        uncommitted: bool,

    ) -> Result<()> {

        self.manifest_cache.take();

        self.listing_cache.take();

        let p = self.manifest_path();

        };

            }

    }

    /// Forget the manifest after an operation that changed the working-copy

    }

    fn parse_manifest(&self, path: &std::path::Path) -> Result<Option<(bool, bool, Manifest)>> {

            Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(None),

            Err(e) => return Err(e.into()),

        };

    }

    /// Whether the working copy is certainly clean, known from the manifest

            let path = self.root.join(rel);

            let same = match fs::symlink_metadata(&path) {

                Ok(md) if md.file_type().is_symlink() => fs::read_link(&path).is_ok_and(|t| {

                }),

                Ok(md) if md.is_file() => {

                    md.len() == e.size

                }

                _ => false,

            };

                manifest

                    .entries

                    .get(rel)

            });

            if links_differ {

                return Ok(true);

                        || super::is_executable(m) != me.exec

                        || (mtime_ns(m) != me.mtime_ns

                            && !fs::read(path)

                })

            });

            if files_differ {

                if m.len() != me.size

                    || super::is_executable(&m) != me.exec

                    || (mtime_ns(&m) != me.mtime_ns

                {

                    return Ok(true);

                }

            t

        };

        // A text file's graph key, worked out when the walk asks for it.

            let e = view.entries.get(p)?;

            if e.kind != NodeKind::File || e.mode.opaque {

                return None;

            }

        };

        let mut fs_entries = {

            let _t = crate::timing::phase("snapshot: read working copy");

        };

        // The keys of the files read, before building graphs drops them: a

        // file found equal to its base rendering keeps its key.

            .iter()

            .filter(|(_, e)| !e.unchanged && e.kind == NodeKind::File)

            .filter_map(|(p, _)| Some((p.clone(), key_of(p)?)))

                        bytes,

                        materialized,

                    }) if !materialized.is_conflicted() && *bytes == *e.content => {

                    }

                    _ => None,

                };

    /// The graph key of each text file of the state at `heads`, by path,

    /// from a history-only load that builds no graph. Files with an `eol`

    /// attribute are left out: their bytes on disk are not the rendering.

        let _t = crate::timing::phase("commit: graph keys");

        let attrs = self.disk_attributes();

        st.tree()

            .filter(|(p, e)| {

                e.kind == NodeKind::File && !e.mode.opaque && attrs.lookup(p).eol.is_none()

            })

            .collect()

    }