A commit writes the manifest once (refs #41) 236f35c0baba

        };

        let r = self.store.put(ObjectType::Op, &op.encode())?;

        // The head is the commit point: everything it names must be on disk first.

        self.store.flush()?;

        // Compare and swap under a short lock (spec §12.1): when another

        // process recorded an operation since this one read the head, the

        // two are merged instead of one overwriting the other.

pub(crate) type CachedManifest = ((u64, u128, u64), (bool, bool, std::sync::Arc<Manifest>));

/// Now, in nanoseconds since the epoch.

    std::time::SystemTime::now()

        .duration_since(UNIX_EPOCH)

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

        entries: &BTreeMap<String, FsEntry>,

        blobs: &HashMap<String, ObjectRef>,

    ) -> Result<()> {

        self.manifest_cache.take();

        self.listing_cache.take();

        let mut newest_ns: u128 = 0;

        let mut rows = entries.iter().map(|(path, e)| {

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

            };

            (path.as_str(), entry)

        });

        let new = encode_manifest(conflicted, uncommitted, written, &dirs, &nested, &mut rows);

        drop(rows);

        let p = self.manifest_path();

    /// Folders holding a repository of their own (`.git` or `.oxy`) that

    /// are not subrepos, so nothing in them is tracked (oxygen#43).

    pub untracked_nested: Vec<String>,

}

pub fn is_binary(content: &[u8]) -> bool {

    content[..content.len().min(BINARY_SNIFF)].contains(&0)

}

                    }))

            }

        };

        let attributes = crate::attributes::Attributes::from_files(

            fs_entries

                .iter()

                .filter(|(p, _)| is_attributes(p))

                .map(|(p, e)| (p.as_str(), e.content.as_slice())),

        );

        Ok(SnapshotResult {

            wc_hash: new_hash,

            wc,

            contributors,

            attributes,

            untracked_nested: self.untracked_nested.borrow().clone(),

        })

    }

        out

    }

    fn commit_selection_batched(

        &self,

        message: &str,

            Some(snap) => snap,

            None => self.snapshot_as("oxy commit", true, true)?,

        };

        if snap.wc.tree_ops.is_empty() && snap.wc.edits.is_empty() {

            return fail("nothing to commit: the working copy matches its base");

        }

        if let Some(s) = snap

        // commit just extended: a file whose graph it built has none, and

        // is read by the next snapshot; a key the next base does not share

        // (the bookmark held other heads) is simply not trusted then.

        let committed_keys =

            (!partial).then(|| self.committed_graph_keys(&st, &changed_paths, &snap.attributes));

        let recording = crate::timing::phase("commit: record");

        let wc = self.new_working_copy(wc_base, "");

        let wc_hash = self.store.put_change(&wc)?;

        view.workspaces.insert(self.workspace, wc_hash);

        self.record_op(&[op_ref], &format!("oxy commit -m {message:?}"), view)?;

        drop(recording);

        if partial {

            // The rest is rebuilt from disk by the next snapshot.

            self.drop_manifest();

            } else {

                committed_keys.unwrap_or_default()

            };

        }

        self.maybe_autopack()?;

        let _ = self.run_hook(

            "post-commit",

            &format!(

            contributors: Vec::new(),

            attributes,

            untracked_nested: self.untracked_nested.borrow().clone(),

        }))

    }