diff --git a/Cargo.lock b/Cargo.lock
index 811a8c2cb35..9332cc33cb1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1737,6 +1737,7 @@ dependencies = [
  "once_cell",
  "pretty_assertions",
  "serde",
+ "smallvec",
  "thiserror 2.0.12",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index e868f2b8306..f16f3b46008 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -377,3 +377,7 @@ no_effect_underscore_binding = "allow"  # x1
 empty_docs = "allow"
 too_long_first_doc_paragraph = "allow"
 large_stack_arrays = "allow"
+
+# Fix one day
+result_large_err = "allow"
+large_enum_variant = "allow"
diff --git a/examples/log.rs b/examples/log.rs
index 37e3a9f7b7f..0ca592cb57d 100644
--- a/examples/log.rs
+++ b/examples/log.rs
@@ -150,7 +150,7 @@ fn run(args: Args) -> anyhow::Result<()> {
                         commit_ref.author.actor().write_to(&mut buf)?;
                         buf.into()
                     },
-                    time: commit_ref.author.time.format(format::DEFAULT),
+                    time: commit_ref.author.time()?.format(format::DEFAULT),
                     message: commit_ref.message.to_owned(),
                 })
             }),
diff --git a/gitoxide-core/src/corpus/engine.rs b/gitoxide-core/src/corpus/engine.rs
index e48292246d6..6482cea9c78 100644
--- a/gitoxide-core/src/corpus/engine.rs
+++ b/gitoxide-core/src/corpus/engine.rs
@@ -57,8 +57,9 @@ impl Engine {
         let repos = self.refresh_repos(&corpus_path, corpus_id)?;
         self.state.progress.set_name("refresh repos".into());
         self.state.progress.info(format!(
-            "Added or updated {} repositories under {corpus_path:?}",
-            repos.len()
+            "Added or updated {} repositories under '{corpus_path}'",
+            repos.len(),
+            corpus_path = corpus_path.display(),
         ));
         Ok(())
     }
@@ -316,7 +317,7 @@ impl Engine {
                                 out.push(repo);
                                 progress.inc();
                             }
-                            Err(err) => progress.fail(format!("{repo_path:?}: {err:#?}")),
+                            Err(err) => progress.fail(format!("{repo_path}: {err:#?}", repo_path = repo_path.display())),
                         }
                     }
                     statement.finalize()?;
diff --git a/gitoxide-core/src/hours/core.rs b/gitoxide-core/src/hours/core.rs
index 58221ca638c..110fc24d983 100644
--- a/gitoxide-core/src/hours/core.rs
+++ b/gitoxide-core/src/hours/core.rs
@@ -17,7 +17,7 @@ const MINUTES_PER_HOUR: f32 = 60.0;
 pub const HOURS_PER_WORKDAY: f32 = 8.0;
 
 pub fn estimate_hours(
-    commits: &[(u32, gix::actor::SignatureRef<'static>)],
+    commits: &[(u32, super::SignatureRef<'static>)],
     stats: &[(u32, FileStats, LineStats)],
 ) -> WorkByEmail {
     assert!(!commits.is_empty());
@@ -31,7 +31,7 @@ pub fn estimate_hours(
         let mut cur = commits.next().expect("at least one commit if we are here");
 
         for next in commits {
-            let change_in_minutes = (next.time.seconds.saturating_sub(cur.time.seconds)) as f32 / MINUTES_PER_HOUR;
+            let change_in_minutes = (next.seconds().saturating_sub(cur.seconds())) as f32 / MINUTES_PER_HOUR;
             if change_in_minutes < MAX_COMMIT_DIFFERENCE_IN_MINUTES {
                 hours += change_in_minutes / MINUTES_PER_HOUR;
             } else {
@@ -166,13 +166,11 @@ pub fn spawn_tree_delta_threads<'scope>(
                                             (true, true) => {
                                                 files.modified += 1;
                                                 if let Some(cache) = cache.as_mut() {
-                                                    let mut diff = change.diff(cache).map_err(|err| {
-                                                        std::io::Error::new(std::io::ErrorKind::Other, err)
-                                                    })?;
+                                                    let mut diff = change.diff(cache).map_err(std::io::Error::other)?;
                                                     let mut nl = 0;
-                                                    if let Some(counts) = diff.line_counts().map_err(|err| {
-                                                        std::io::Error::new(std::io::ErrorKind::Other, err)
-                                                    })? {
+                                                    if let Some(counts) =
+                                                        diff.line_counts().map_err(std::io::Error::other)?
+                                                    {
                                                         nl += counts.insertions as usize + counts.removals as usize;
                                                         lines.added += counts.insertions as usize;
                                                         lines.removed += counts.removals as usize;
diff --git a/gitoxide-core/src/hours/mod.rs b/gitoxide-core/src/hours/mod.rs
index b233e013d46..f8b16887073 100644
--- a/gitoxide-core/src/hours/mod.rs
+++ b/gitoxide-core/src/hours/mod.rs
@@ -2,7 +2,6 @@ use std::{collections::BTreeSet, io, path::Path, time::Instant};
 
 use anyhow::bail;
 use gix::{
-    actor,
     bstr::{BStr, ByteSlice},
     prelude::*,
     progress, Count, NestedProgress, Progress,
@@ -27,6 +26,18 @@ pub struct Context<W> {
     pub out: W,
 }
 
+pub struct SignatureRef<'a> {
+    name: &'a BStr,
+    email: &'a BStr,
+    time: gix::date::Time,
+}
+
+impl SignatureRef<'_> {
+    fn seconds(&self) -> gix::date::SecondsSinceUnixEpoch {
+        self.time.seconds
+    }
+}
+
 /// Estimate the hours it takes to produce the content of the repository in `_working_dir_`, with `_refname_` for
 /// the start of the commit graph traversal.
 ///
@@ -85,7 +96,7 @@ where
 
                         out.push((
                             commit_idx,
-                            actor::SignatureRef {
+                            SignatureRef {
                                 name,
                                 email,
                                 time: author.time,
@@ -97,7 +108,7 @@ where
                 out.sort_by(|a, b| {
                     a.1.email
                         .cmp(b.1.email)
-                        .then(a.1.time.seconds.cmp(&b.1.time.seconds).reverse())
+                        .then(a.1.seconds().cmp(&b.1.seconds()).reverse())
                 });
                 Ok(out)
             });
diff --git a/gitoxide-core/src/lib.rs b/gitoxide-core/src/lib.rs
index a33b76a349a..8b24ab2e51e 100644
--- a/gitoxide-core/src/lib.rs
+++ b/gitoxide-core/src/lib.rs
@@ -30,9 +30,10 @@
 #![deny(rust_2018_idioms)]
 #![forbid(unsafe_code)]
 
-use anyhow::bail;
 use std::str::FromStr;
 
+use anyhow::bail;
+
 #[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
 pub enum OutputFormat {
     Human,
diff --git a/gitoxide-core/src/organize.rs b/gitoxide-core/src/organize.rs
index 4b7000af62d..625e328411f 100644
--- a/gitoxide-core/src/organize.rs
+++ b/gitoxide-core/src/organize.rs
@@ -1,5 +1,5 @@
-use std::borrow::Cow;
 use std::{
+    borrow::Cow,
     ffi::OsStr,
     path::{Path, PathBuf},
 };
@@ -138,9 +138,9 @@ fn handle(
 
     if let Some(parent_repo_path) = find_parent_repo(git_workdir) {
         progress.fail(format!(
-            "Skipping repository at {:?} as it is nested within repository {:?}",
+            "Skipping repository at '{}' as it is nested within repository '{}'",
             git_workdir.display(),
-            parent_repo_path
+            parent_repo_path.display()
         ));
         return Ok(());
     }
@@ -157,7 +157,7 @@ fn handle(
     };
     if url.path.is_empty() {
         progress.info(format!(
-            "Skipping repository at {:?} whose remote does not have a path: {:?}",
+            "Skipping repository at '{}' whose remote does not have a path: {}",
             git_workdir.display(),
             url.to_bstring()
         ));
diff --git a/gitoxide-core/src/pack/receive.rs b/gitoxide-core/src/pack/receive.rs
index 5c717ed12db..66b64d95f24 100644
--- a/gitoxide-core/src/pack/receive.rs
+++ b/gitoxide-core/src/pack/receive.rs
@@ -1,10 +1,10 @@
-use crate::net;
-use crate::pack::receive::protocol::fetch::negotiate;
-use crate::OutputFormat;
-use gix::config::tree::Key;
-use gix::protocol::maybe_async;
-use gix::remote::fetch::Error;
-use gix::DynNestedProgress;
+use std::{
+    io,
+    path::PathBuf,
+    sync::{atomic::AtomicBool, Arc},
+};
+
+use gix::{config::tree::Key, protocol::maybe_async, remote::fetch::Error, DynNestedProgress};
 pub use gix::{
     hash::ObjectId,
     objs::bstr::{BString, ByteSlice},
@@ -18,11 +18,8 @@ pub use gix::{
     },
     NestedProgress, Progress,
 };
-use std::{
-    io,
-    path::PathBuf,
-    sync::{atomic::AtomicBool, Arc},
-};
+
+use crate::{net, pack::receive::protocol::fetch::negotiate, OutputFormat};
 
 pub const PROGRESS_RANGE: std::ops::RangeInclusive<u8> = 1..=3;
 pub struct Context<W> {
@@ -294,7 +291,7 @@ fn receive_pack_blocking(
         None::<gix::objs::find::Never>,
         options,
     )
-    .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
+    .map_err(io::Error::other)?;
 
     if let Some(directory) = refs_directory.take() {
         write_raw_refs(refs, directory)?;
diff --git a/gitoxide-core/src/query/db.rs b/gitoxide-core/src/query/db.rs
index df1099e50ba..ab483aef036 100644
--- a/gitoxide-core/src/query/db.rs
+++ b/gitoxide-core/src/query/db.rs
@@ -19,8 +19,12 @@ pub fn create(path: impl AsRef<std::path::Path>) -> anyhow::Result<rusqlite::Con
         }
         Some(version) if version != VERSION => match con.close() {
             Ok(()) => {
-                std::fs::remove_file(path)
-                    .with_context(|| format!("Failed to remove incompatible database file at {path:?}"))?;
+                std::fs::remove_file(path).with_context(|| {
+                    format!(
+                        "Failed to remove incompatible database file at {path}",
+                        path = path.display()
+                    )
+                })?;
                 con = rusqlite::Connection::open(path)?;
                 con.execute_batch(meta_table)?;
                 con.execute("INSERT into meta(version) values(?)", params![VERSION])?;
diff --git a/gitoxide-core/src/query/engine/command.rs b/gitoxide-core/src/query/engine/command.rs
index 31246b0676d..1b020030821 100644
--- a/gitoxide-core/src/query/engine/command.rs
+++ b/gitoxide-core/src/query/engine/command.rs
@@ -76,7 +76,7 @@ impl query::Engine {
                             usize,
                         ) = row?;
                         let id = gix::ObjectId::from(hash);
-                        let commit_time = id.attach(&self.repo).object()?.into_commit().committer()?.time;
+                        let commit_time = id.attach(&self.repo).object()?.into_commit().committer()?.time()?;
                         let mode = FileMode::from_usize(mode).context("invalid file mode")?;
                         info.push(trace_path::Info {
                             id,
diff --git a/gitoxide-core/src/repository/archive.rs b/gitoxide-core/src/repository/archive.rs
index c229fe976b8..0f61b387a71 100644
--- a/gitoxide-core/src/repository/archive.rs
+++ b/gitoxide-core/src/repository/archive.rs
@@ -84,7 +84,7 @@ fn fetch_rev_info(
     Ok(match object.kind {
         gix::object::Kind::Commit => {
             let commit = object.into_commit();
-            (Some(commit.committer()?.time.seconds), commit.tree_id()?.detach())
+            (Some(commit.committer()?.seconds()), commit.tree_id()?.detach())
         }
         gix::object::Kind::Tree => (None, object.id),
         gix::object::Kind::Tag => fetch_rev_info(object.peel_to_kind(gix::object::Kind::Commit)?)?,
diff --git a/gitoxide-core/src/repository/attributes/query.rs b/gitoxide-core/src/repository/attributes/query.rs
index b12421e77df..6929f4b9bbd 100644
--- a/gitoxide-core/src/repository/attributes/query.rs
+++ b/gitoxide-core/src/repository/attributes/query.rs
@@ -8,10 +8,10 @@ pub struct Options {
 }
 
 pub(crate) mod function {
+    use std::{borrow::Cow, io, path::Path};
+
     use anyhow::bail;
     use gix::bstr::BStr;
-    use std::borrow::Cow;
-    use std::{io, path::Path};
 
     use crate::{
         is_dir_to_mode,
diff --git a/gitoxide-core/src/repository/attributes/validate_baseline.rs b/gitoxide-core/src/repository/attributes/validate_baseline.rs
index 51de5d5382b..763b14a4325 100644
--- a/gitoxide-core/src/repository/attributes/validate_baseline.rs
+++ b/gitoxide-core/src/repository/attributes/validate_baseline.rs
@@ -44,8 +44,8 @@ pub(crate) mod function {
         if repo.is_bare() {
             writeln!(
                 err,
-                "Repo {:?} is bare - disabling git-ignore baseline as `git check-ignore` needs a worktree",
-                repo.path()
+                "Repo at '{repo}' is bare - disabling git-ignore baseline as `git check-ignore` needs a worktree",
+                repo = repo.path().display()
             )
             .ok();
             ignore = false;
diff --git a/gitoxide-core/src/repository/blame.rs b/gitoxide-core/src/repository/blame.rs
index 04744515343..0d42c75f9e0 100644
--- a/gitoxide-core/src/repository/blame.rs
+++ b/gitoxide-core/src/repository/blame.rs
@@ -1,7 +1,7 @@
-use gix::bstr::ByteSlice;
-use gix::config::tree;
 use std::ffi::OsStr;
 
+use gix::{bstr::ByteSlice, config::tree};
+
 pub fn blame_file(
     mut repo: gix::Repository,
     file: &OsStr,
diff --git a/gitoxide-core/src/repository/cat.rs b/gitoxide-core/src/repository/cat.rs
index 2407b4c0a0e..72433ed2d3d 100644
--- a/gitoxide-core/src/repository/cat.rs
+++ b/gitoxide-core/src/repository/cat.rs
@@ -1,8 +1,7 @@
-use crate::repository::revision::resolve::{BlobFormat, TreeMode};
 use anyhow::{anyhow, Context};
-use gix::diff::blob::ResourceKind;
-use gix::filter::plumbing::driver::apply::Delay;
-use gix::revision::Spec;
+use gix::{diff::blob::ResourceKind, filter::plumbing::driver::apply::Delay, revision::Spec};
+
+use crate::repository::revision::resolve::{BlobFormat, TreeMode};
 
 pub fn display_object(
     repo: &gix::Repository,
diff --git a/gitoxide-core/src/repository/clean.rs b/gitoxide-core/src/repository/clean.rs
index 1146f4b2fb0..5534424479e 100644
--- a/gitoxide-core/src/repository/clean.rs
+++ b/gitoxide-core/src/repository/clean.rs
@@ -20,17 +20,23 @@ pub struct Options {
     pub find_untracked_repositories: FindRepository,
 }
 pub(crate) mod function {
-    use crate::repository::clean::{FindRepository, Options};
-    use crate::OutputFormat;
+    use std::{borrow::Cow, path::Path};
+
     use anyhow::bail;
-    use gix::bstr::BString;
-    use gix::bstr::ByteSlice;
-    use gix::dir::entry::{Kind, Status};
-    use gix::dir::walk::EmissionMode::CollapseDirectory;
-    use gix::dir::walk::ForDeletionMode::*;
-    use gix::dir::{walk, EntryRef};
-    use std::borrow::Cow;
-    use std::path::Path;
+    use gix::{
+        bstr::{BString, ByteSlice},
+        dir::{
+            entry::{Kind, Status},
+            walk,
+            walk::{EmissionMode::CollapseDirectory, ForDeletionMode::*},
+            EntryRef,
+        },
+    };
+
+    use crate::{
+        repository::clean::{FindRepository, Options},
+        OutputFormat,
+    };
 
     pub fn clean(
         repo: gix::Repository,
diff --git a/gitoxide-core/src/repository/diff.rs b/gitoxide-core/src/repository/diff.rs
index 600eaf2efff..a0396599b81 100644
--- a/gitoxide-core/src/repository/diff.rs
+++ b/gitoxide-core/src/repository/diff.rs
@@ -1,12 +1,16 @@
 use anyhow::Context;
-use gix::bstr::{BString, ByteSlice};
-use gix::diff::blob::intern::TokenSource;
-use gix::diff::blob::unified_diff::{ContextSize, NewlineSeparator};
-use gix::diff::blob::UnifiedDiff;
-use gix::objs::tree::EntryMode;
-use gix::odb::store::RefreshMode;
-use gix::prelude::ObjectIdExt;
-use gix::ObjectId;
+use gix::{
+    bstr::{BString, ByteSlice},
+    diff::blob::{
+        intern::TokenSource,
+        unified_diff::{ContextSize, NewlineSeparator},
+        UnifiedDiff,
+    },
+    objs::tree::EntryMode,
+    odb::store::RefreshMode,
+    prelude::ObjectIdExt,
+    ObjectId,
+};
 
 pub fn tree(
     mut repo: gix::Repository,
diff --git a/gitoxide-core/src/repository/dirty.rs b/gitoxide-core/src/repository/dirty.rs
index 8981199d532..44d176b4f05 100644
--- a/gitoxide-core/src/repository/dirty.rs
+++ b/gitoxide-core/src/repository/dirty.rs
@@ -1,6 +1,7 @@
-use crate::OutputFormat;
 use anyhow::bail;
 
+use crate::OutputFormat;
+
 pub enum Mode {
     IsClean,
     IsDirty,
diff --git a/gitoxide-core/src/repository/fetch.rs b/gitoxide-core/src/repository/fetch.rs
index 7be5ef9d076..21198349bb3 100644
--- a/gitoxide-core/src/repository/fetch.rs
+++ b/gitoxide-core/src/repository/fetch.rs
@@ -169,7 +169,7 @@ pub(crate) mod function {
 
         let start = std::time::Instant::now();
         progress.set_name("layout graph".into());
-        progress.info(format!("writing {path:?}…"));
+        progress.info(format!("writing {}…", path.display()));
         let mut svg = SVGWriter::new();
         vg.do_it(false, false, false, &mut svg);
         std::fs::write(path, svg.finalize().as_bytes())?;
diff --git a/gitoxide-core/src/repository/index/entries.rs b/gitoxide-core/src/repository/index/entries.rs
index 470fdd3bd0b..e72a46b483b 100644
--- a/gitoxide-core/src/repository/index/entries.rs
+++ b/gitoxide-core/src/repository/index/entries.rs
@@ -23,9 +23,9 @@ pub(crate) mod function {
         io::{BufWriter, Write},
     };
 
-    use gix::index::entry::Stage;
     use gix::{
         bstr::{BStr, BString},
+        index::entry::Stage,
         worktree::IndexPersistedOrInMemory,
         Repository,
     };
diff --git a/gitoxide-core/src/repository/mailmap.rs b/gitoxide-core/src/repository/mailmap.rs
index 44fc0036155..9252bdafde0 100644
--- a/gitoxide-core/src/repository/mailmap.rs
+++ b/gitoxide-core/src/repository/mailmap.rs
@@ -1,7 +1,7 @@
-use anyhow::bail;
-use gix::bstr::{BString, ByteSlice};
 use std::io;
 
+use anyhow::bail;
+use gix::bstr::{BString, ByteSlice};
 #[cfg(feature = "serde")]
 use gix::mailmap::Entry;
 
diff --git a/gitoxide-core/src/repository/merge/commit.rs b/gitoxide-core/src/repository/merge/commit.rs
index 6982cc2b8a7..a745962dff9 100644
--- a/gitoxide-core/src/repository/merge/commit.rs
+++ b/gitoxide-core/src/repository/merge/commit.rs
@@ -1,11 +1,12 @@
-use crate::OutputFormat;
 use anyhow::{anyhow, bail, Context};
-use gix::bstr::BString;
-use gix::bstr::ByteSlice;
-use gix::merge::tree::TreatAsUnresolved;
-use gix::prelude::Write;
+use gix::{
+    bstr::{BString, ByteSlice},
+    merge::tree::TreatAsUnresolved,
+    prelude::Write,
+};
 
 use super::tree::Options;
+use crate::OutputFormat;
 
 #[allow(clippy::too_many_arguments)]
 pub fn commit(
diff --git a/gitoxide-core/src/repository/merge/file.rs b/gitoxide-core/src/repository/merge/file.rs
index 7e183c8a9e6..4fde1bbf24d 100644
--- a/gitoxide-core/src/repository/merge/file.rs
+++ b/gitoxide-core/src/repository/merge/file.rs
@@ -1,15 +1,19 @@
-use crate::OutputFormat;
-use anyhow::{anyhow, bail, Context};
-use gix::bstr::BString;
-use gix::bstr::ByteSlice;
-use gix::merge::blob::builtin_driver::binary;
-use gix::merge::blob::builtin_driver::text::Conflict;
-use gix::merge::blob::pipeline::WorktreeRoots;
-use gix::merge::blob::{Resolution, ResourceKind};
-use gix::object::tree::EntryKind;
-use gix::Id;
 use std::path::Path;
 
+use anyhow::{anyhow, bail, Context};
+use gix::{
+    bstr::{BString, ByteSlice},
+    merge::blob::{
+        builtin_driver::{binary, text::Conflict},
+        pipeline::WorktreeRoots,
+        Resolution, ResourceKind,
+    },
+    object::tree::EntryKind,
+    Id,
+};
+
+use crate::OutputFormat;
+
 pub fn file(
     repo: gix::Repository,
     out: &mut dyn std::io::Write,
diff --git a/gitoxide-core/src/repository/merge/tree.rs b/gitoxide-core/src/repository/merge/tree.rs
index 0d6467b09da..1a008208a2d 100644
--- a/gitoxide-core/src/repository/merge/tree.rs
+++ b/gitoxide-core/src/repository/merge/tree.rs
@@ -10,14 +10,15 @@ pub struct Options {
 
 pub(super) mod function {
 
-    use crate::OutputFormat;
     use anyhow::{anyhow, bail, Context};
-    use gix::bstr::BString;
-    use gix::bstr::ByteSlice;
-    use gix::merge::tree::TreatAsUnresolved;
-    use gix::prelude::Write;
+    use gix::{
+        bstr::{BString, ByteSlice},
+        merge::tree::TreatAsUnresolved,
+        prelude::Write,
+    };
 
     use super::Options;
+    use crate::OutputFormat;
 
     #[allow(clippy::too_many_arguments)]
     pub fn tree(
diff --git a/gitoxide-core/src/repository/merge_base.rs b/gitoxide-core/src/repository/merge_base.rs
index 8a0b8515c8d..b6140ec9d4b 100644
--- a/gitoxide-core/src/repository/merge_base.rs
+++ b/gitoxide-core/src/repository/merge_base.rs
@@ -1,6 +1,7 @@
-use crate::OutputFormat;
 use anyhow::bail;
 
+use crate::OutputFormat;
+
 pub fn merge_base(
     mut repo: gix::Repository,
     first: String,
diff --git a/gitoxide-core/src/repository/odb.rs b/gitoxide-core/src/repository/odb.rs
index c386450c8d6..599e6f7e42e 100644
--- a/gitoxide-core/src/repository/odb.rs
+++ b/gitoxide-core/src/repository/odb.rs
@@ -1,5 +1,4 @@
-use std::io;
-use std::sync::atomic::Ordering;
+use std::{io, sync::atomic::Ordering};
 
 use anyhow::bail;
 
diff --git a/gitoxide-core/src/repository/revision/list.rs b/gitoxide-core/src/repository/revision/list.rs
index 1698a29d494..c47f1bc3b27 100644
--- a/gitoxide-core/src/repository/revision/list.rs
+++ b/gitoxide-core/src/repository/revision/list.rs
@@ -117,7 +117,7 @@ pub(crate) mod function {
         if let Some((mut vg, path, _)) = vg {
             let start = std::time::Instant::now();
             progress.set_name("layout graph".into());
-            progress.info(format!("writing {path:?}…"));
+            progress.info(format!("writing {}…", path.display()));
             let mut svg = SVGWriter::new();
             vg.do_it(false, false, false, &mut svg);
             std::fs::write(&path, svg.finalize().as_bytes())?;
diff --git a/gitoxide-core/src/repository/revision/resolve.rs b/gitoxide-core/src/repository/revision/resolve.rs
index 60686d14830..7ef4c5bd9a2 100644
--- a/gitoxide-core/src/repository/revision/resolve.rs
+++ b/gitoxide-core/src/repository/revision/resolve.rs
@@ -28,9 +28,10 @@ pub(crate) mod function {
     use gix::revision::Spec;
 
     use super::Options;
-    use crate::repository::cat::display_object;
-    use crate::repository::revision::resolve::BlobFormat;
-    use crate::{repository::revision, OutputFormat};
+    use crate::{
+        repository::{cat::display_object, revision, revision::resolve::BlobFormat},
+        OutputFormat,
+    };
 
     pub fn resolve(
         mut repo: gix::Repository,
diff --git a/gitoxide-core/src/repository/status.rs b/gitoxide-core/src/repository/status.rs
index 9804dfa214c..77d94322e35 100644
--- a/gitoxide-core/src/repository/status.rs
+++ b/gitoxide-core/src/repository/status.rs
@@ -1,8 +1,11 @@
+use std::path::Path;
+
 use anyhow::bail;
-use gix::bstr::{BStr, BString, ByteSlice};
-use gix::status::{self, index_worktree};
+use gix::{
+    bstr::{BStr, BString, ByteSlice},
+    status::{self, index_worktree},
+};
 use gix_status::index_as_worktree::{Change, Conflict, EntryStatus};
-use std::path::Path;
 
 use crate::OutputFormat;
 
diff --git a/gitoxide-core/src/repository/tree.rs b/gitoxide-core/src/repository/tree.rs
index fcde83f8fb1..b57e72022b9 100644
--- a/gitoxide-core/src/repository/tree.rs
+++ b/gitoxide-core/src/repository/tree.rs
@@ -1,17 +1,18 @@
+use std::{borrow::Cow, io, io::BufWriter};
+
 use anyhow::bail;
 use gix::Tree;
-use std::io::BufWriter;
-use std::{borrow::Cow, io};
 
 use crate::OutputFormat;
 
 mod entries {
+    use std::collections::VecDeque;
+
     use gix::{
         bstr::{BStr, BString, ByteSlice, ByteVec},
         objs::tree::EntryRef,
         traverse::tree::visit::Action,
     };
-    use std::collections::VecDeque;
 
     use crate::repository::tree::format_entry;
 
diff --git a/gitoxide-core/src/repository/worktree.rs b/gitoxide-core/src/repository/worktree.rs
index 9eea9ec662e..e3a373eb80c 100644
--- a/gitoxide-core/src/repository/worktree.rs
+++ b/gitoxide-core/src/repository/worktree.rs
@@ -1,6 +1,7 @@
-use crate::OutputFormat;
 use anyhow::bail;
 
+use crate::OutputFormat;
+
 pub fn list(repo: gix::Repository, out: &mut dyn std::io::Write, format: OutputFormat) -> anyhow::Result<()> {
     if format != OutputFormat::Human {
         bail!("JSON output isn't implemented yet");
diff --git a/gix-actor/src/lib.rs b/gix-actor/src/lib.rs
index ec182e96d1d..e5f7ac87cd0 100644
--- a/gix-actor/src/lib.rs
+++ b/gix-actor/src/lib.rs
@@ -6,8 +6,7 @@
     doc = ::document_features::document_features!()
 )]
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg, doc_auto_cfg))]
-#![deny(missing_docs, rust_2018_idioms)]
-#![forbid(unsafe_code)]
+#![deny(missing_docs, rust_2018_idioms, unsafe_code)]
 
 /// The re-exported `bstr` crate.
 ///
@@ -18,7 +17,6 @@ use bstr::{BStr, BString};
 ///
 /// For convenience to allow using `gix-date` without adding it to own cargo manifest.
 pub use gix_date as date;
-use gix_date::Time;
 
 mod identity;
 ///
@@ -53,7 +51,7 @@ pub struct IdentityRef<'a> {
     pub email: &'a BStr,
 }
 
-/// A mutable signature is created by an actor at a certain time.
+/// A mutable signature that is created by an actor at a certain time.
 ///
 /// Note that this is not a cryptographical signature.
 #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
@@ -68,10 +66,10 @@ pub struct Signature {
     /// Use [SignatureRef::trim()] or trim manually to be able to clean it up.
     pub email: BString,
     /// The time stamp at which the signature is performed.
-    pub time: Time,
+    pub time: date::Time,
 }
 
-/// A immutable signature is created by an actor at a certain time.
+/// An immutable signature that is created by an actor at a certain time.
 ///
 /// Note that this is not a cryptographical signature.
 #[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
@@ -86,6 +84,6 @@ pub struct SignatureRef<'a> {
     ///
     /// Use [SignatureRef::trim()] or trim manually to be able to clean it up.
     pub email: &'a BStr,
-    /// The time stamp at which the signature was performed.
-    pub time: gix_date::Time,
+    /// The timestamp at which the signature was performed.
+    pub time: &'a str,
 }
diff --git a/gix-actor/src/signature/decode.rs b/gix-actor/src/signature/decode.rs
index fecdfaf773b..87f5680c3ba 100644
--- a/gix-actor/src/signature/decode.rs
+++ b/gix-actor/src/signature/decode.rs
@@ -1,19 +1,14 @@
 pub(crate) mod function {
-    use crate::{IdentityRef, SignatureRef};
     use bstr::ByteSlice;
-    use gix_date::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
-    use gix_utils::btoi::to_signed;
-    use winnow::error::ErrMode;
-    use winnow::stream::Stream;
     use winnow::{
-        combinator::{alt, opt, separated_pair, terminated},
-        error::{AddContext, ParserError, StrContext},
+        combinator::{opt, separated_pair},
+        error::{AddContext, ErrMode, ParserError, StrContext},
         prelude::*,
-        stream::AsChar,
-        token::{take, take_until, take_while},
+        stream::{AsChar, Stream},
+        token::take_while,
     };
 
-    const SPACE: &[u8] = b" ";
+    use crate::{IdentityRef, SignatureRef};
 
     /// Parse a signature from the bytes input `i` using `nom`.
     pub fn decode<'a, E: ParserError<&'a [u8]> + AddContext<&'a [u8], StrContext>>(
@@ -23,36 +18,17 @@ pub(crate) mod function {
             identity,
             opt(b" "),
             opt((
-                terminated(take_until(0.., SPACE), take(1usize))
-                    .verify_map(|v| to_signed::<SecondsSinceUnixEpoch>(v).ok())
-                    .context(StrContext::Expected("<timestamp>".into())),
-                alt((
-                    take_while(1.., b'-').map(|_| Sign::Minus),
-                    take_while(1.., b'+').map(|_| Sign::Plus),
-                ))
-                .context(StrContext::Expected("+|-".into())),
-                take_while(2, AsChar::is_dec_digit)
-                    .verify_map(|v| to_signed::<OffsetInSeconds>(v).ok())
-                    .context(StrContext::Expected("HH".into())),
-                take_while(1..=2, AsChar::is_dec_digit)
-                    .verify_map(|v| to_signed::<OffsetInSeconds>(v).ok())
-                    .context(StrContext::Expected("MM".into())),
-                take_while(0.., AsChar::is_dec_digit).map(|v: &[u8]| v),
+                take_while(0.., |b: u8| b == b'+' || b == b'-' || b.is_space() || b.is_dec_digit()).map(|v: &[u8]| v),
             ))
-            .map(|maybe_timestamp| {
-                if let Some((time, sign, hours, minutes, trailing_digits)) = maybe_timestamp {
-                    let offset = if trailing_digits.is_empty() {
-                        (hours * 3600 + minutes * 60) * if sign == Sign::Minus { -1 } else { 1 }
-                    } else {
-                        0
-                    };
-                    Time {
-                        seconds: time,
-                        offset,
-                        sign,
+            .map(|maybe_bytes| {
+                if let Some((bytes,)) = maybe_bytes {
+                    // SAFETY: The parser validated that there are only ASCII characters.
+                    #[allow(unsafe_code)]
+                    unsafe {
+                        std::str::from_utf8_unchecked(bytes)
                     }
                 } else {
-                    Time::new(0, 0)
+                    ""
                 }
             }),
         )
@@ -108,12 +84,10 @@ pub use function::identity;
 #[cfg(test)]
 mod tests {
     mod parse_signature {
-        use bstr::ByteSlice;
-        use gix_date::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch};
         use gix_testtools::to_bstr_err;
         use winnow::prelude::*;
 
-        use crate::{signature, SignatureRef, Time};
+        use crate::{signature, SignatureRef};
 
         fn decode<'i>(
             i: &mut &'i [u8],
@@ -121,28 +95,31 @@ mod tests {
             signature::decode.parse_next(i)
         }
 
-        fn signature(
-            name: &'static str,
-            email: &'static str,
-            seconds: SecondsSinceUnixEpoch,
-            sign: Sign,
-            offset: OffsetInSeconds,
-        ) -> SignatureRef<'static> {
+        fn signature(name: &'static str, email: &'static str, time: &'static str) -> SignatureRef<'static> {
             SignatureRef {
-                name: name.as_bytes().as_bstr(),
-                email: email.as_bytes().as_bstr(),
-                time: Time { seconds, offset, sign },
+                name: name.into(),
+                email: email.into(),
+                time,
             }
         }
 
         #[test]
         fn tz_minus() {
+            let actual = decode
+                .parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 -0230")
+                .expect("parse to work")
+                .1;
             assert_eq!(
-                decode
-                    .parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 -0230")
-                    .expect("parse to work")
-                    .1,
-                signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Minus, -9000)
+                actual,
+                signature("Sebastian Thiel", "byronimo@gmail.com", "1528473343 -0230")
+            );
+            assert_eq!(actual.seconds(), 1528473343);
+            assert_eq!(
+                actual.time().expect("valid"),
+                gix_date::Time {
+                    seconds: 1528473343,
+                    offset: -9000,
+                }
             );
         }
 
@@ -153,7 +130,7 @@ mod tests {
                     .parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 +0230")
                     .expect("parse to work")
                     .1,
-                signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Plus, 9000)
+                signature("Sebastian Thiel", "byronimo@gmail.com", "1528473343 +0230")
             );
         }
 
@@ -164,7 +141,7 @@ mod tests {
                     .parse_peek(b"Sebastian Thiel <\tbyronimo@gmail.com > 1528473343 +0230")
                     .expect("parse to work")
                     .1,
-                signature("Sebastian Thiel", "\tbyronimo@gmail.com ", 1528473343, Sign::Plus, 9000)
+                signature("Sebastian Thiel", "\tbyronimo@gmail.com ", "1528473343 +0230")
             );
         }
 
@@ -175,7 +152,7 @@ mod tests {
                     .parse_peek(b"Sebastian Thiel <byronimo@gmail.com> 1528473343 -0000")
                     .expect("parse to work")
                     .1,
-                signature("Sebastian Thiel", "byronimo@gmail.com", 1528473343, Sign::Minus, 0)
+                signature("Sebastian Thiel", "byronimo@gmail.com", "1528473343 -0000")
             );
         }
 
@@ -186,7 +163,7 @@ mod tests {
                     .parse_peek(b"name <name@example.com> 1288373970 --700")
                     .expect("parse to work")
                     .1,
-                signature("name", "name@example.com", 1288373970, Sign::Minus, -252000)
+                signature("name", "name@example.com", "1288373970 --700")
             );
         }
 
@@ -194,7 +171,7 @@ mod tests {
         fn empty_name_and_email() {
             assert_eq!(
                 decode.parse_peek(b" <> 12345 -1215").expect("parse to work").1,
-                signature("", "", 12345, Sign::Minus, -44100)
+                signature("", "", "12345 -1215")
             );
         }
 
@@ -213,7 +190,7 @@ mod tests {
         fn invalid_time() {
             assert_eq!(
                 decode.parse_peek(b"hello <> abc -1215").expect("parse to work").1,
-                signature("hello", "", 0, Sign::Plus, 0)
+                signature("hello", "", "")
             );
         }
     }
diff --git a/gix-actor/src/signature/mod.rs b/gix-actor/src/signature/mod.rs
index 9a9a0510a6c..f7f7b331e43 100644
--- a/gix-actor/src/signature/mod.rs
+++ b/gix-actor/src/signature/mod.rs
@@ -4,6 +4,7 @@ mod _ref {
 
     use crate::{signature::decode, IdentityRef, Signature, SignatureRef};
 
+    /// Lifecycle
     impl<'a> SignatureRef<'a> {
         /// Deserialize a signature from the given `data`.
         pub fn from_bytes<E>(mut data: &'a [u8]) -> Result<SignatureRef<'a>, winnow::error::ErrMode<E>>
@@ -14,67 +15,85 @@ mod _ref {
         }
 
         /// Create an owned instance from this shared one.
-        pub fn to_owned(&self) -> Signature {
-            Signature {
+        pub fn to_owned(&self) -> Result<Signature, gix_date::parse::Error> {
+            Ok(Signature {
                 name: self.name.to_owned(),
                 email: self.email.to_owned(),
-                time: self.time,
-            }
+                time: self.time()?,
+            })
         }
+    }
 
-        /// Trim whitespace surrounding the name and email and return a new signature.
+    /// Access
+    impl<'a> SignatureRef<'a> {
+        /// Trim the whitespace surrounding the `name`, `email` and `time` and return a new signature.
         pub fn trim(&self) -> SignatureRef<'a> {
             SignatureRef {
                 name: self.name.trim().as_bstr(),
                 email: self.email.trim().as_bstr(),
-                time: self.time,
+                time: self.time.trim(),
             }
         }
 
-        /// Return the actor's name and email, effectively excluding the time stamp of this signature.
+        /// Return the actor's name and email, effectively excluding the timestamp of this signature.
         pub fn actor(&self) -> IdentityRef<'a> {
             IdentityRef {
                 name: self.name,
                 email: self.email,
             }
         }
+
+        /// Parse only the seconds since unix epoch from the `time` field, or silently default to 0
+        /// if parsing fails. Note that this ignores the timezone, so it can parse otherwise broken dates.
+        ///
+        /// For a fallible and more complete, but slower version, use [`time()`](Self::time).
+        pub fn seconds(&self) -> gix_date::SecondsSinceUnixEpoch {
+            self.time
+                .trim()
+                .split(' ')
+                .next()
+                .and_then(|i| i.parse().ok())
+                .unwrap_or_default()
+        }
+
+        /// Parse the `time` field for access to the passed time since unix epoch, and the time offset.
+        /// The format is expected to be [raw](gix_date::parse_header()).
+        pub fn time(&self) -> Result<gix_date::Time, gix_date::parse::Error> {
+            self.time.parse()
+        }
     }
 }
 
 mod convert {
+    use gix_date::parse::TimeBuf;
+
     use crate::{Signature, SignatureRef};
 
     impl Signature {
-        /// Borrow this instance as immutable
-        pub fn to_ref(&self) -> SignatureRef<'_> {
+        /// Borrow this instance as immutable, serializing the `time` field into `buf`.
+        pub fn to_ref<'a>(&'a self, time_buf: &'a mut TimeBuf) -> SignatureRef<'a> {
             SignatureRef {
                 name: self.name.as_ref(),
                 email: self.email.as_ref(),
-                time: self.time,
+                time: self.time.to_str(time_buf),
             }
         }
     }
 
     impl From<SignatureRef<'_>> for Signature {
         fn from(other: SignatureRef<'_>) -> Signature {
-            let SignatureRef { name, email, time } = other;
             Signature {
-                name: name.to_owned(),
-                email: email.to_owned(),
-                time,
+                name: other.name.to_owned(),
+                email: other.email.to_owned(),
+                time: other.time().unwrap_or_default(),
             }
         }
     }
-
-    impl<'a> From<&'a Signature> for SignatureRef<'a> {
-        fn from(other: &'a Signature) -> SignatureRef<'a> {
-            other.to_ref()
-        }
-    }
 }
 
 pub(crate) mod write {
     use bstr::{BStr, ByteSlice};
+    use gix_date::parse::TimeBuf;
 
     use crate::{Signature, SignatureRef};
 
@@ -96,11 +115,12 @@ pub(crate) mod write {
     impl Signature {
         /// Serialize this instance to `out` in the git serialization format for actors.
         pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
-            self.to_ref().write_to(out)
+            let mut buf = TimeBuf::default();
+            self.to_ref(&mut buf).write_to(out)
         }
         /// Computes the number of bytes necessary to serialize this signature
         pub fn size(&self) -> usize {
-            self.to_ref().size()
+            self.name.len() + 2 /* space <*/ + self.email.len() +  2 /* > space */ + self.time.size()
         }
     }
 
@@ -112,11 +132,11 @@ pub(crate) mod write {
             out.write_all(b"<")?;
             out.write_all(validated_token(self.email)?)?;
             out.write_all(b"> ")?;
-            self.time.write_to(out)
+            out.write_all(validated_token(self.time.into())?)
         }
         /// Computes the number of bytes necessary to serialize this signature
         pub fn size(&self) -> usize {
-            self.name.len() + 2 /* space <*/ + self.email.len() +  2 /* > space */ + self.time.size()
+            self.name.len() + 2 /* space <*/ + self.email.len() +  2 /* > space */ + self.time.len()
         }
     }
 
diff --git a/gix-actor/tests/signature/mod.rs b/gix-actor/tests/signature/mod.rs
index 15a04f6a6c9..a007ad871a7 100644
--- a/gix-actor/tests/signature/mod.rs
+++ b/gix-actor/tests/signature/mod.rs
@@ -1,14 +1,14 @@
 mod write_to {
     mod invalid {
         use gix_actor::Signature;
-        use gix_date::{time::Sign, Time};
+        use gix_date::Time;
 
         #[test]
         fn name() {
             let signature = Signature {
                 name: "invalid < middlename".into(),
                 email: "ok".into(),
-                time: default_time(),
+                time: Time::default(),
             };
             assert_eq!(
                 format!("{:?}", signature.write_to(&mut Vec::new())),
@@ -21,7 +21,7 @@ mod write_to {
             let signature = Signature {
                 name: "ok".into(),
                 email: "server>.example.com".into(),
-                time: default_time(),
+                time: Time::default(),
             };
             assert_eq!(
                 format!("{:?}", signature.write_to(&mut Vec::new())),
@@ -34,21 +34,13 @@ mod write_to {
             let signature = Signature {
                 name: "hello\nnewline".into(),
                 email: "name@example.com".into(),
-                time: default_time(),
+                time: Time::default(),
             };
             assert_eq!(
                 format!("{:?}", signature.write_to(&mut Vec::new())),
                 "Err(Custom { kind: Other, error: IllegalCharacter })"
             );
         }
-
-        fn default_time() -> Time {
-            Time {
-                seconds: 0,
-                offset: 0,
-                sign: Sign::Plus,
-            }
-        }
     }
 }
 
@@ -81,6 +73,16 @@ fn round_trip() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+#[test]
+fn signature_ref_round_trips_with_seconds_in_offset() -> Result<(), Box<dyn std::error::Error>> {
+    let input = b"Sebastian Thiel <byronimo@gmail.com> 1313584730 +051800"; // Seen in the wild
+    let signature: SignatureRef = gix_actor::SignatureRef::from_bytes::<()>(input).unwrap();
+    let mut output = Vec::new();
+    signature.write_to(&mut output)?;
+    assert_eq!(output.as_bstr(), input.as_bstr());
+    Ok(())
+}
+
 #[test]
 fn parse_timestamp_with_trailing_digits() {
     let signature = gix_actor::SignatureRef::from_bytes::<()>(b"first last <name@example.com> 1312735823 +051800")
@@ -90,7 +92,7 @@ fn parse_timestamp_with_trailing_digits() {
         SignatureRef {
             name: "first last".into(),
             email: "name@example.com".into(),
-            time: gix_actor::date::Time::new(1312735823, 0),
+            time: "1312735823 +051800",
         }
     );
 
@@ -101,7 +103,7 @@ fn parse_timestamp_with_trailing_digits() {
         SignatureRef {
             name: "first last".into(),
             email: "name@example.com".into(),
-            time: gix_actor::date::Time::new(1312735823, 19080),
+            time: "1312735823 +0518",
         }
     );
 }
@@ -115,7 +117,7 @@ fn parse_missing_timestamp() {
         SignatureRef {
             name: "first last".into(),
             email: "name@example.com".into(),
-            time: gix_actor::date::Time::new(0, 0),
+            time: ""
         }
     );
 }
diff --git a/gix-attributes/src/name.rs b/gix-attributes/src/name.rs
index c8d50743a1e..6ca70248a1c 100644
--- a/gix-attributes/src/name.rs
+++ b/gix-attributes/src/name.rs
@@ -1,7 +1,8 @@
-use crate::{Name, NameRef};
 use bstr::{BStr, BString, ByteSlice};
 use kstring::KStringRef;
 
+use crate::{Name, NameRef};
+
 impl NameRef<'_> {
     /// Turn this ref into its owned counterpart.
     pub fn to_owned(self) -> Name {
diff --git a/gix-attributes/src/parse.rs b/gix-attributes/src/parse.rs
index 600c7c1191e..6bbf9bf23c4 100644
--- a/gix-attributes/src/parse.rs
+++ b/gix-attributes/src/parse.rs
@@ -1,9 +1,10 @@
 use std::borrow::Cow;
 
-use crate::{name, AssignmentRef, Name, NameRef, StateRef};
 use bstr::{BStr, ByteSlice};
 use kstring::KStringRef;
 
+use crate::{name, AssignmentRef, Name, NameRef, StateRef};
+
 /// The kind of attribute that was parsed.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/gix-attributes/src/search/mod.rs b/gix-attributes/src/search/mod.rs
index db17f01fe36..83c6d41929c 100644
--- a/gix-attributes/src/search/mod.rs
+++ b/gix-attributes/src/search/mod.rs
@@ -1,6 +1,7 @@
+use std::collections::HashMap;
+
 use kstring::KString;
 use smallvec::SmallVec;
-use std::collections::HashMap;
 
 use crate::{Assignment, AssignmentRef};
 
diff --git a/gix-attributes/src/state.rs b/gix-attributes/src/state.rs
index 21e51faedf1..c3ff5e35a0b 100644
--- a/gix-attributes/src/state.rs
+++ b/gix-attributes/src/state.rs
@@ -1,6 +1,7 @@
-use crate::{State, StateRef};
 use bstr::{BStr, BString, ByteSlice};
 
+use crate::{State, StateRef};
+
 /// A container to encapsulate a tightly packed and typically unallocated byte value that isn't necessarily UTF8 encoded.
 #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
diff --git a/gix-attributes/tests/parse/mod.rs b/gix-attributes/tests/parse/mod.rs
index 75000826327..0092b38928c 100644
--- a/gix-attributes/tests/parse/mod.rs
+++ b/gix-attributes/tests/parse/mod.rs
@@ -1,6 +1,5 @@
 use bstr::BString;
-use gix_attributes::state::ValueRef;
-use gix_attributes::{parse, StateRef};
+use gix_attributes::{parse, state::ValueRef, StateRef};
 use gix_glob::pattern::Mode;
 use gix_testtools::fixture_bytes;
 
diff --git a/gix-blame/src/file/function.rs b/gix-blame/src/file/function.rs
index 08d90b0127d..12ef57d374d 100644
--- a/gix-blame/src/file/function.rs
+++ b/gix-blame/src/file/function.rs
@@ -1,7 +1,6 @@
-use super::{process_changes, Change, UnblamedHunk};
-use crate::{BlameEntry, Error, Options, Outcome, Statistics};
-use gix_diff::blob::intern::TokenSource;
-use gix_diff::tree::Visit;
+use std::{num::NonZeroU32, ops::Range};
+
+use gix_diff::{blob::intern::TokenSource, tree::Visit};
 use gix_hash::ObjectId;
 use gix_object::{
     bstr::{BStr, BString},
@@ -9,8 +8,9 @@ use gix_object::{
 };
 use gix_traverse::commit::find as find_commit;
 use smallvec::SmallVec;
-use std::num::NonZeroU32;
-use std::ops::Range;
+
+use super::{process_changes, Change, UnblamedHunk};
+use crate::{BlameEntry, Error, Options, Outcome, Statistics};
 
 /// Produce a list of consecutive [`BlameEntry`] instances to indicate in which commits the ranges of the file
 /// at `suspect:<file_path>` originated in.
@@ -499,8 +499,7 @@ fn tree_diff_at_file_path(
         }
 
         fn visit(&mut self, change: gix_diff::tree::visit::Change) -> gix_diff::tree::visit::Action {
-            use gix_diff::tree::visit;
-            use gix_diff::tree::visit::Change::*;
+            use gix_diff::tree::{visit, visit::Change::*};
 
             if self.inner.path() == self.interesting_path {
                 self.change = Some(match change {
@@ -672,7 +671,7 @@ type CommitTime = i64;
 fn commit_time(commit: gix_traverse::commit::Either<'_, '_>) -> Result<CommitTime, gix_object::decode::Error> {
     match commit {
         gix_traverse::commit::Either::CommitRefIter(commit_ref_iter) => {
-            commit_ref_iter.committer().map(|c| c.time.seconds)
+            commit_ref_iter.committer().map(|c| c.seconds())
         }
         gix_traverse::commit::Either::CachedCommit(commit) => Ok(commit.committer_timestamp() as i64),
     }
@@ -701,7 +700,7 @@ fn collect_parents(
             for id in commit_ref_iter.parent_ids() {
                 let parent = odb.find_commit_iter(id.as_ref(), buf).ok();
                 let parent_commit_time = parent
-                    .and_then(|parent| parent.committer().ok().map(|committer| committer.time.seconds))
+                    .and_then(|parent| parent.committer().ok().map(|committer| committer.seconds()))
                     .unwrap_or_default();
                 parent_ids.push((id, parent_commit_time));
             }
diff --git a/gix-blame/src/file/mod.rs b/gix-blame/src/file/mod.rs
index 4783ab30b19..bbca9681837 100644
--- a/gix-blame/src/file/mod.rs
+++ b/gix-blame/src/file/mod.rs
@@ -1,12 +1,10 @@
 //! A module with low-level types and functions.
 
-use std::num::NonZeroU32;
-use std::ops::Range;
+use std::{num::NonZeroU32, ops::Range};
 
 use gix_hash::ObjectId;
 
-use crate::types::{BlameEntry, Either, LineRange};
-use crate::types::{Change, Offset, UnblamedHunk};
+use crate::types::{BlameEntry, Change, Either, LineRange, Offset, UnblamedHunk};
 
 pub(super) mod function;
 
diff --git a/gix-blame/src/file/tests.rs b/gix-blame/src/file/tests.rs
index 1366fcfea9c..02e7d89ebd1 100644
--- a/gix-blame/src/file/tests.rs
+++ b/gix-blame/src/file/tests.rs
@@ -1,7 +1,9 @@
-use crate::file::{Offset, UnblamedHunk};
-use gix_hash::ObjectId;
 use std::ops::Range;
 
+use gix_hash::ObjectId;
+
+use crate::file::{Offset, UnblamedHunk};
+
 fn new_unblamed_hunk(range_in_blamed_file: Range<u32>, suspect: ObjectId, offset: Offset) -> UnblamedHunk {
     assert!(
         range_in_blamed_file.end > range_in_blamed_file.start,
@@ -957,8 +959,11 @@ mod process_change {
 }
 
 mod process_changes {
-    use crate::file::tests::{new_unblamed_hunk, one_sha, zero_sha};
-    use crate::file::{process_changes, Change, Offset, UnblamedHunk};
+    use crate::file::{
+        process_changes,
+        tests::{new_unblamed_hunk, one_sha, zero_sha},
+        Change, Offset, UnblamedHunk,
+    };
 
     #[test]
     fn nothing() {
diff --git a/gix-blame/src/types.rs b/gix-blame/src/types.rs
index f7fdb6608d1..bc01e4d8bec 100644
--- a/gix-blame/src/types.rs
+++ b/gix-blame/src/types.rs
@@ -1,9 +1,13 @@
-use crate::file::function::tokens_for_diffing;
+use std::{
+    num::NonZeroU32,
+    ops::{AddAssign, Range, SubAssign},
+};
+
 use gix_hash::ObjectId;
 use gix_object::bstr::BString;
 use smallvec::SmallVec;
-use std::num::NonZeroU32;
-use std::ops::{AddAssign, Range, SubAssign};
+
+use crate::file::function::tokens_for_diffing;
 
 /// Options to be passed to [`file()`](crate::file()).
 #[derive(Default, Debug, Clone)]
diff --git a/gix-command/src/lib.rs b/gix-command/src/lib.rs
index 8199d0c186a..a3c428edeba 100644
--- a/gix-command/src/lib.rs
+++ b/gix-command/src/lib.rs
@@ -2,9 +2,9 @@
 #![deny(rust_2018_idioms, missing_docs)]
 #![forbid(unsafe_code)]
 
-use std::io::Read;
 use std::{
     ffi::OsString,
+    io::Read,
     path::{Path, PathBuf},
 };
 
@@ -85,8 +85,8 @@ pub struct Context {
 }
 
 mod prepare {
-    use std::borrow::Cow;
     use std::{
+        borrow::Cow,
         ffi::OsString,
         process::{Command, Stdio},
     };
@@ -425,9 +425,9 @@ pub fn extract_interpreter(executable: &Path) -> Option<shebang::Data> {
 
 ///
 pub mod shebang {
+    use std::{ffi::OsString, path::PathBuf};
+
     use bstr::{BStr, ByteSlice};
-    use std::ffi::OsString;
-    use std::path::PathBuf;
 
     /// Parse `buf` to extract all shebang information.
     pub fn parse(buf: &BStr) -> Option<Data> {
diff --git a/gix-command/tests/command.rs b/gix-command/tests/command.rs
index 30b29977563..6ab8775afe9 100644
--- a/gix-command/tests/command.rs
+++ b/gix-command/tests/command.rs
@@ -1,6 +1,7 @@
-use gix_testtools::Result;
 use std::path::Path;
 
+use gix_testtools::Result;
+
 #[test]
 fn extract_interpreter() -> gix_testtools::Result {
     let root = gix_testtools::scripted_fixture_read_only("win_path_lookup.sh")?;
@@ -79,8 +80,9 @@ mod shebang {
 
             #[cfg(unix)]
             {
-                use bstr::ByteSlice;
                 use std::os::unix::ffi::OsStrExt;
+
+                use bstr::ByteSlice;
                 assert_eq!(
                     shebang::parse(b"#!/bin/sh   -x \xC3\x28\x41 -y  ".as_bstr()),
                     Some(shebang::Data {
diff --git a/gix-commitgraph/src/file/init.rs b/gix-commitgraph/src/file/init.rs
index 022cc7b7ea2..07bfdee3642 100644
--- a/gix-commitgraph/src/file/init.rs
+++ b/gix-commitgraph/src/file/init.rs
@@ -1,5 +1,6 @@
-use std::path::Path;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+
+use bstr::ByteSlice;
 
 use crate::{
     file::{
@@ -8,7 +9,6 @@ use crate::{
     },
     File,
 };
-use bstr::ByteSlice;
 
 /// The error used in [`File::at()`].
 #[derive(thiserror::Error, Debug)]
diff --git a/gix-config/src/file/access/comfort.rs b/gix-config/src/file/access/comfort.rs
index 6a75188d016..44b69cda6f5 100644
--- a/gix-config/src/file/access/comfort.rs
+++ b/gix-config/src/file/access/comfort.rs
@@ -2,8 +2,7 @@ use std::borrow::Cow;
 
 use bstr::BStr;
 
-use crate::file::Metadata;
-use crate::{value, AsKey, File};
+use crate::{file::Metadata, value, AsKey, File};
 
 /// Comfortable API for accessing values
 impl File<'_> {
diff --git a/gix-config/src/file/access/mutate.rs b/gix-config/src/file/access/mutate.rs
index 3da5f178bf4..167d7c6a2f3 100644
--- a/gix-config/src/file/access/mutate.rs
+++ b/gix-config/src/file/access/mutate.rs
@@ -3,9 +3,8 @@ use std::borrow::Cow;
 use bstr::BStr;
 use gix_features::threading::OwnShared;
 
-use crate::file::Metadata;
 use crate::{
-    file::{self, rename_section, write::ends_with_newline, SectionBodyIdsLut, SectionId, SectionMut},
+    file::{self, rename_section, write::ends_with_newline, Metadata, SectionBodyIdsLut, SectionId, SectionMut},
     lookup,
     parse::{section, Event, FrontMatterEvents},
     File,
diff --git a/gix-config/src/file/access/raw.rs b/gix-config/src/file/access/raw.rs
index c2b8c967f7f..4c8f73d4c6d 100644
--- a/gix-config/src/file/access/raw.rs
+++ b/gix-config/src/file/access/raw.rs
@@ -3,9 +3,8 @@ use std::{borrow::Cow, collections::HashMap};
 use bstr::BStr;
 use smallvec::ToSmallVec;
 
-use crate::file::Metadata;
 use crate::{
-    file::{mutable::multi_value::EntryData, Index, MultiValueMut, Size, ValueMut},
+    file::{mutable::multi_value::EntryData, Index, Metadata, MultiValueMut, Size, ValueMut},
     lookup,
     parse::{section, Event},
     AsKey, File,
diff --git a/gix-config/src/file/includes/types.rs b/gix-config/src/file/includes/types.rs
index ed55ffe47c3..340d4fdaaf1 100644
--- a/gix-config/src/file/includes/types.rs
+++ b/gix-config/src/file/includes/types.rs
@@ -1,6 +1,7 @@
-use crate::{parse, path::interpolate};
 use std::path::PathBuf;
 
+use crate::{parse, path::interpolate};
+
 /// The error returned when following includes.
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-config/src/file/mutable/section.rs b/gix-config/src/file/mutable/section.rs
index d41f2f6e8f5..ec38ab85e2c 100644
--- a/gix-config/src/file/mutable/section.rs
+++ b/gix-config/src/file/mutable/section.rs
@@ -3,6 +3,10 @@ use std::{
     ops::{Deref, Range},
 };
 
+use bstr::{BStr, BString, ByteSlice, ByteVec};
+use gix_sec::Trust;
+use smallvec::SmallVec;
+
 use crate::{
     file::{
         self,
@@ -13,9 +17,6 @@ use crate::{
     parse::{section::ValueName, Event},
     value::{normalize, normalize_bstr, normalize_bstring},
 };
-use bstr::{BStr, BString, ByteSlice, ByteVec};
-use gix_sec::Trust;
-use smallvec::SmallVec;
 
 /// A opaque type that represents a mutable reference to a section.
 #[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
diff --git a/gix-config/src/key.rs b/gix-config/src/key.rs
index cba7d92dce9..cdbae4e6dc8 100644
--- a/gix-config/src/key.rs
+++ b/gix-config/src/key.rs
@@ -1,5 +1,4 @@
-use bstr::BStr;
-use bstr::ByteSlice;
+use bstr::{BStr, ByteSlice};
 
 /// Parse parts of a Git configuration key, like `remote.origin.url` or `core.bare`.
 pub trait AsKey {
diff --git a/gix-config/src/parse/tests.rs b/gix-config/src/parse/tests.rs
index 75c53fb677e..703f8a2167a 100644
--- a/gix-config/src/parse/tests.rs
+++ b/gix-config/src/parse/tests.rs
@@ -1,9 +1,10 @@
 mod section {
-    use crate::parse::section::Header;
-    use crate::parse::{section, Comment, Event, Events, Section};
-    use bstr::BStr;
     use std::borrow::Cow;
 
+    use bstr::BStr;
+
+    use crate::parse::{section, section::Header, Comment, Event, Events, Section};
+
     #[test]
     #[cfg(target_pointer_width = "64")]
     fn size_of_events() {
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs
index 9e6dbbf4697..b7057d8351b 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/conditional/gitdir/util.rs
@@ -142,8 +142,8 @@ pub fn assert_section_value(
             Some(Value::Override) => Some(cow_str("override-value")),
             None => None,
         },
-        "gix-config disagrees with the expected value, {:?} for debugging",
-        env.tempdir.into_path()
+        "gix-config disagrees with the expected value, {} for debugging",
+        env.tempdir.into_path().display()
     );
     assure_git_agrees(expected, env)
 }
@@ -171,9 +171,9 @@ fn assure_git_agrees(expected: Option<Value>, env: GitEnv) -> crate::Result {
     assert_eq!(
         output.status.success(),
         expected.is_some(),
-        "{:?}, {:?} for debugging",
+        "{:?}, {} for debugging",
         output,
-        env.tempdir.into_path()
+        env.tempdir.into_path().display()
     );
     let git_output: BString = output.stdout.trim_end().into();
     assert_eq!(
diff --git a/gix-config/tests/config/file/init/from_paths/includes/conditional/hasconfig.rs b/gix-config/tests/config/file/init/from_paths/includes/conditional/hasconfig.rs
index 5ed6de7a030..27ab7a7b7c0 100644
--- a/gix-config/tests/config/file/init/from_paths/includes/conditional/hasconfig.rs
+++ b/gix-config/tests/config/file/init/from_paths/includes/conditional/hasconfig.rs
@@ -1,6 +1,7 @@
-use gix_config::file::{includes, init};
 use std::path::{Path, PathBuf};
 
+use gix_config::file::{includes, init};
+
 #[test]
 fn simple() -> crate::Result {
     let (config, root) = config_with_includes("basic")?;
diff --git a/gix-config/tests/config/mod.rs b/gix-config/tests/config/mod.rs
index 2782af4095a..93a04387fbf 100644
--- a/gix-config/tests/config/mod.rs
+++ b/gix-config/tests/config/mod.rs
@@ -1,3 +1,4 @@
+#![allow(clippy::unnecessary_debug_formatting)]
 pub use gix_testtools::Result;
 
 mod file;
diff --git a/gix-config/tests/config/source/mod.rs b/gix-config/tests/config/source/mod.rs
index 26dc4e093bc..9bc63d14135 100644
--- a/gix-config/tests/config/source/mod.rs
+++ b/gix-config/tests/config/source/mod.rs
@@ -1,6 +1,7 @@
-use gix_config::Source;
 use std::path::Path;
 
+use gix_config::Source;
+
 #[test]
 fn git_config_no_system() {
     assert_eq!(
diff --git a/gix-config/tests/mem.rs b/gix-config/tests/mem.rs
index 5c65cb26d6c..7bbde99e22f 100644
--- a/gix-config/tests/mem.rs
+++ b/gix-config/tests/mem.rs
@@ -1,7 +1,7 @@
+use std::{alloc, time::Instant};
+
 use bytesize::ByteSize;
 use cap::Cap;
-use std::alloc;
-use std::time::Instant;
 
 #[global_allocator]
 static ALLOCATOR: Cap<alloc::System> = Cap::new(alloc::System, usize::MAX);
diff --git a/gix-date/Cargo.toml b/gix-date/Cargo.toml
index 1c6acca213b..b0c67c1b744 100644
--- a/gix-date/Cargo.toml
+++ b/gix-date/Cargo.toml
@@ -24,6 +24,9 @@ serde = { version = "1.0.114", optional = true, default-features = false, featur
 itoa = "1.0.1"
 jiff = "0.2.10"
 thiserror = "2.0.0"
+# TODO: used for quick and easy `TimeBacking: std::io::Write` implementation, but could make that `Copy`
+#       and remove this dep with custom impl
+smallvec = { version = "1.15.0", features = ["write"] }
 
 document-features = { version = "0.2.0", optional = true }
 
diff --git a/gix-date/src/lib.rs b/gix-date/src/lib.rs
index 20893a7cab8..68d39dfda84 100644
--- a/gix-date/src/lib.rs
+++ b/gix-date/src/lib.rs
@@ -7,29 +7,25 @@
     doc = ::document_features::document_features!()
 )]
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg, doc_auto_cfg))]
-#![deny(missing_docs, rust_2018_idioms)]
-#![forbid(unsafe_code)]
-
+#![deny(missing_docs, rust_2018_idioms, unsafe_code)]
 ///
 pub mod time;
 
 ///
 pub mod parse;
-pub use parse::function::parse;
+pub use parse::function::{parse, parse_header};
 
 /// A timestamp with timezone.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+#[derive(Default, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time {
-    /// The seconds that passed since UNIX epoch. This makes it UTC, or `<seconds>+0000`.
+    /// The seconds that have passed since UNIX epoch. This makes it UTC, or `<seconds>+0000`.
     pub seconds: SecondsSinceUnixEpoch,
     /// The time's offset in seconds, which may be negative to match the `sign` field.
     pub offset: OffsetInSeconds,
-    /// the sign of `offset`, used to encode `-0000` which would otherwise lose sign information.
-    pub sign: time::Sign,
 }
 
-/// The amount of seconds since unix epoch.
+/// The number of seconds since unix epoch.
 ///
 /// Note that negative dates represent times before the unix epoch.
 ///
diff --git a/gix-date/src/parse.rs b/gix-date/src/parse.rs
index afd3470ac60..2dfba0f0532 100644
--- a/gix-date/src/parse.rs
+++ b/gix-date/src/parse.rs
@@ -1,3 +1,9 @@
+use std::str::FromStr;
+
+use smallvec::SmallVec;
+
+use crate::Time;
+
 #[derive(thiserror::Error, Debug, Clone)]
 #[allow(missing_docs)]
 pub enum Error {
@@ -11,6 +17,61 @@ pub enum Error {
     MissingCurrentTime,
 }
 
+/// A container for just enough bytes to hold the largest-possible [`time`](Time) instance.
+/// It's used in conjunction with
+#[derive(Default, Clone)]
+pub struct TimeBuf {
+    buf: SmallVec<[u8; Time::MAX.size()]>,
+}
+
+impl TimeBuf {
+    /// Represent this instance as standard string, serialized in a format compatible with
+    /// signature fields in Git commits, also known as anything parseable as [raw format](function::parse_header()).
+    pub fn as_str(&self) -> &str {
+        // SAFETY: We know that serialized times are pure ASCII, a subset of UTF-8.
+        //         `buf` and `len` are written only by time-serialization code.
+        let time_bytes = self.buf.as_slice();
+        #[allow(unsafe_code)]
+        unsafe {
+            std::str::from_utf8_unchecked(time_bytes)
+        }
+    }
+
+    /// Clear the previous content.
+    fn clear(&mut self) {
+        self.buf.clear();
+    }
+}
+
+impl std::io::Write for TimeBuf {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.buf.write(buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.buf.flush()
+    }
+}
+
+impl Time {
+    /// Serialize this instance into `buf`, exactly as it would appear in the header of a Git commit,
+    /// and return `buf` as `&str` for easy consumption.
+    pub fn to_str<'a>(&self, buf: &'a mut TimeBuf) -> &'a str {
+        buf.clear();
+        self.write_to(buf)
+            .expect("write to memory of just the right size cannot fail");
+        buf.as_str()
+    }
+}
+
+impl FromStr for Time {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        crate::parse_header(s).ok_or_else(|| Error::InvalidDateString { input: s.into() })
+    }
+}
+
 pub(crate) mod function {
     use std::{str::FromStr, time::SystemTime};
 
@@ -18,14 +79,71 @@ pub(crate) mod function {
 
     use crate::{
         parse::{relative, Error},
-        time::{
-            format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
-            Sign,
-        },
-        SecondsSinceUnixEpoch, Time,
+        time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
+        OffsetInSeconds, SecondsSinceUnixEpoch, Time,
     };
 
-    #[allow(missing_docs)]
+    /// Parse `input` as any time that Git can parse when inputting a date.
+    ///
+    /// ## Examples
+    ///
+    /// ### 1. SHORT Format
+    ///
+    /// *   `2018-12-24`
+    /// *   `1970-01-01`
+    /// *   `1950-12-31`
+    /// *   `2024-12-31`
+    ///
+    /// ### 2. RFC2822 Format
+    ///
+    /// *   `Thu, 18 Aug 2022 12:45:06 +0800`
+    /// *   `Mon Oct 27 10:30:00 2023 -0800`
+    ///
+    /// ### 3. GIT_RFC2822 Format
+    ///
+    /// *   `Thu, 8 Aug 2022 12:45:06 +0800`
+    /// *   `Mon Oct 27 10:30:00 2023 -0800` (Note the single-digit day)
+    ///
+    /// ### 4. ISO8601 Format
+    ///
+    /// *   `2022-08-17 22:04:58 +0200`
+    /// *   `1970-01-01 00:00:00 -0500`
+    ///
+    /// ### 5. ISO8601_STRICT Format
+    ///
+    /// *   `2022-08-17T21:43:13+08:00`
+    ///
+    /// ### 6. UNIX Timestamp (Seconds Since Epoch)
+    ///
+    /// *   `123456789`
+    /// *   `0` (January 1, 1970 UTC)
+    /// *   `-1000`
+    /// *   `1700000000`
+    ///
+    /// ### 7. Commit Header Format
+    ///
+    /// *   `1745582210 +0200`
+    /// *   `1660874655 +0800`
+    /// *   `-1660874655 +0800`
+    ///
+    /// See also the [`parse_header()`].
+    ///
+    /// ### 8. GITOXIDE Format
+    ///
+    /// *   `Thu Sep 04 2022 10:45:06 -0400`
+    /// *   `Mon Oct 27 2023 10:30:00 +0000`
+    ///
+    /// ### 9. DEFAULT Format
+    ///
+    /// *   `Thu Sep 4 10:45:06 2022 -0400`
+    /// *   `Mon Oct 27 10:30:00 2023 +0000`
+    ///
+    /// ### 10. Relative Dates (e.g., "2 minutes ago", "1 hour from now")
+    ///
+    /// These dates are parsed *relative to a `now` timestamp*. The examples depend entirely on the value of `now`.
+    /// If `now` is October 27, 2023 at 10:00:00 UTC:
+    ///     *   `2 minutes ago` (October 27, 2023 at 09:58:00 UTC)
+    ///     *   `3 hours ago` (October 27, 2023 at 07:00:00 UTC)
     pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
         // TODO: actual implementation, this is just to not constantly fail
         if input == "1979-02-26 18:30:00" {
@@ -50,39 +168,73 @@ pub(crate) mod function {
         } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
             // Format::Unix
             Time::new(val, 0)
-        } else if let Some(val) = parse_raw(input) {
-            // Format::Raw
-            val
         } else if let Some(val) = relative::parse(input, now).transpose()? {
             Time::new(val.timestamp().as_second(), val.offset().seconds())
+        } else if let Some(val) = parse_header(input) {
+            // Format::Raw
+            val
         } else {
             return Err(Error::InvalidDateString { input: input.into() });
         })
     }
 
-    fn parse_raw(input: &str) -> Option<Time> {
-        let mut split = input.split_whitespace();
-        let seconds: SecondsSinceUnixEpoch = split.next()?.parse().ok()?;
-        let offset = split.next()?;
-        if offset.len() != 5 || split.next().is_some() {
-            return None;
+    /// Unlike [`parse()`] which handles all kinds of input, this function only parses the commit-header format
+    /// like `1745582210 +0200`.
+    ///
+    /// Note that failure to parse the time zone isn't fatal, instead it will default to `0`. To know if
+    /// the time is wonky, serialize the return value to see if it matches the `input.`
+    pub fn parse_header(input: &str) -> Option<Time> {
+        pub enum Sign {
+            Plus,
+            Minus,
         }
-        let sign = match offset.get(..1)? {
-            "-" => Some(Sign::Minus),
-            "+" => Some(Sign::Plus),
-            _ => None,
-        }?;
-        let hours: i32 = offset.get(1..3)?.parse().ok()?;
-        let minutes: i32 = offset.get(3..5)?.parse().ok()?;
-        let mut offset_in_seconds = hours * 3600 + minutes * 60;
-        if sign == Sign::Minus {
-            offset_in_seconds *= -1;
+        fn parse_offset(offset: &str) -> Option<OffsetInSeconds> {
+            if (offset.len() != 5) && (offset.len() != 7) {
+                return None;
+            }
+            let sign = match offset.get(..1)? {
+                "-" => Some(Sign::Minus),
+                "+" => Some(Sign::Plus),
+                _ => None,
+            }?;
+            if offset.as_bytes().get(1).is_some_and(|b| !b.is_ascii_digit()) {
+                return None;
+            }
+            let hours: i32 = offset.get(1..3)?.parse().ok()?;
+            let minutes: i32 = offset.get(3..5)?.parse().ok()?;
+            let offset_seconds: i32 = if offset.len() == 7 {
+                offset.get(5..7)?.parse().ok()?
+            } else {
+                0
+            };
+            let mut offset_in_seconds = hours * 3600 + minutes * 60 + offset_seconds;
+            if matches!(sign, Sign::Minus) {
+                offset_in_seconds *= -1;
+            }
+            Some(offset_in_seconds)
         }
-        let time = Time {
-            seconds,
-            offset: offset_in_seconds,
-            sign,
+
+        let mut split = input.split_whitespace();
+        let seconds = split.next()?;
+        let seconds = match seconds.parse::<SecondsSinceUnixEpoch>() {
+            Ok(s) => s,
+            Err(_err) => {
+                // Inefficient, but it's not the common case.
+                let first_digits: String = seconds.chars().take_while(char::is_ascii_digit).collect();
+                first_digits.parse().ok()?
+            }
+        };
+        let offset = match split.next() {
+            None => 0,
+            Some(offset) => {
+                if split.next().is_some() {
+                    0
+                } else {
+                    parse_offset(offset).unwrap_or_default()
+                }
+            }
         };
+        let time = Time { seconds, offset };
         Some(time)
     }
 
diff --git a/gix-date/src/time/format.rs b/gix-date/src/time/format.rs
index bfe5583ec93..eeb4bf706b7 100644
--- a/gix-date/src/time/format.rs
+++ b/gix-date/src/time/format.rs
@@ -44,7 +44,7 @@ impl Time {
         match format {
             Format::Custom(CustomFormat(format)) => self.to_time().strftime(format).to_string(),
             Format::Unix => self.seconds.to_string(),
-            Format::Raw => self.to_bstring().to_string(),
+            Format::Raw => self.to_string(),
         }
     }
 }
diff --git a/gix-date/src/time/init.rs b/gix-date/src/time/init.rs
index e7d9adaf62d..3f7f727cadc 100644
--- a/gix-date/src/time/init.rs
+++ b/gix-date/src/time/init.rs
@@ -1,24 +1,16 @@
-use crate::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
+use crate::{OffsetInSeconds, SecondsSinceUnixEpoch, Time};
 
 /// Instantiation
 impl Time {
     /// Create a new instance from seconds and offset.
     pub fn new(seconds: SecondsSinceUnixEpoch, offset: OffsetInSeconds) -> Self {
-        Time {
-            seconds,
-            offset,
-            sign: offset.into(),
-        }
+        Time { seconds, offset }
     }
 
     /// Return the current time without figuring out a timezone offset
     pub fn now_utc() -> Self {
         let seconds = jiff::Timestamp::now().as_second();
-        Self {
-            seconds,
-            offset: 0,
-            sign: Sign::Plus,
-        }
+        Self { seconds, offset: 0 }
     }
 
     /// Return the current local time, or `None` if the local time wasn't available.
@@ -31,10 +23,6 @@ impl Time {
         let zdt = jiff::Zoned::now();
         let seconds = zdt.timestamp().as_second();
         let offset = zdt.offset().seconds();
-        Self {
-            seconds,
-            offset,
-            sign: offset.into(),
-        }
+        Self { seconds, offset }
     }
 }
diff --git a/gix-date/src/time/mod.rs b/gix-date/src/time/mod.rs
index b403decdf88..216a186195a 100644
--- a/gix-date/src/time/mod.rs
+++ b/gix-date/src/time/mod.rs
@@ -8,15 +8,6 @@ impl Time {
     }
 }
 
-/// Indicates if a number is positive or negative for use in [`Time`].
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
-#[allow(missing_docs)]
-pub enum Sign {
-    Plus,
-    Minus,
-}
-
 /// Various ways to describe a time format.
 #[derive(Debug, Clone, Copy)]
 pub enum Format {
@@ -49,31 +40,3 @@ impl From<CustomFormat> for Format {
 pub mod format;
 mod init;
 mod write;
-
-mod sign {
-    use crate::time::Sign;
-
-    impl From<i32> for Sign {
-        fn from(v: i32) -> Self {
-            if v < 0 {
-                Sign::Minus
-            } else {
-                Sign::Plus
-            }
-        }
-    }
-}
-
-mod impls {
-    use crate::{time::Sign, Time};
-
-    impl Default for Time {
-        fn default() -> Self {
-            Time {
-                seconds: 0,
-                offset: 0,
-                sign: Sign::Plus,
-            }
-        }
-    }
-}
diff --git a/gix-date/src/time/write.rs b/gix-date/src/time/write.rs
index 5489dd3871d..0bc1c3ecc8c 100644
--- a/gix-date/src/time/write.rs
+++ b/gix-date/src/time/write.rs
@@ -1,20 +1,21 @@
-use bstr::BString;
+use bstr::ByteSlice;
 
-use crate::{time::Sign, Time};
+use crate::{SecondsSinceUnixEpoch, Time};
 
-/// Serialization with standard `git` format
-impl Time {
-    /// Serialize this instance into memory, similar to what [`write_to()`][Self::write_to()] would do with arbitrary `Write` implementations.
-    ///
-    /// # Panics
-    ///
-    /// If the underlying call fails as this instance can't be represented, typically due to an invalid offset.
-    pub fn to_bstring(&self) -> BString {
-        let mut buf = Vec::with_capacity(64);
+/// Serialize this instance as string, similar to what [`write_to()`](Self::write_to()) would do.
+impl std::fmt::Display for Time {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut buf = Vec::with_capacity(Time::MAX.size());
         self.write_to(&mut buf).expect("write to memory cannot fail");
-        buf.into()
+        // SAFETY: We know time serializes as ASCII, as subset of UTF8.
+        #[allow(unsafe_code)]
+        let raw = unsafe { buf.to_str_unchecked() };
+        f.write_str(raw)
     }
+}
 
+/// Serialization with standard `git` format
+impl Time {
     /// Serialize this instance to `out` in a format suitable for use in header fields of serialized git commits or tags.
     pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {
         const SECONDS_PER_HOUR: u32 = 60 * 60;
@@ -32,10 +33,7 @@ impl Time {
         let mut itoa = itoa::Buffer::new();
         out.write_all(itoa.format(self.seconds).as_bytes())?;
         out.write_all(b" ")?;
-        out.write_all(match self.sign {
-            Sign::Plus => b"+",
-            Sign::Minus => b"-",
-        })?;
+        out.write_all(if self.offset < 0 { b"-" } else { b"+" })?;
 
         const ZERO: &[u8; 1] = b"0";
 
@@ -51,7 +49,7 @@ impl Time {
     }
 
     /// Computes the number of bytes necessary to write it using [`Time::write_to()`].
-    pub fn size(&self) -> usize {
+    pub const fn size(&self) -> usize {
         (if self.seconds >= 1_000_000_000_000_000_000 {
             19
         } else if self.seconds >= 100_000_000_000_000_000 {
@@ -131,4 +129,11 @@ impl Time {
             20
         }) + 2 /*space + offset sign*/ + 2 /*offset hours*/ + 2 /*offset minutes*/
     }
+
+    /// The numerically largest possible time instance, whose [size()](Time::size) is the largest possible
+    /// number of bytes to write using [`Time::write_to()`].
+    pub const MAX: Time = Time {
+        seconds: SecondsSinceUnixEpoch::MAX,
+        offset: 99 * 60 * 60 + 59 * 60 + 59,
+    };
 }
diff --git a/gix-date/tests/time/format.rs b/gix-date/tests/time/format.rs
index c59c8ca693f..06e5b8b774c 100644
--- a/gix-date/tests/time/format.rs
+++ b/gix-date/tests/time/format.rs
@@ -1,5 +1,5 @@
 use gix_date::{
-    time::{format, Format, Sign},
+    time::{format, Format},
     Time,
 };
 
@@ -23,7 +23,6 @@ fn raw() {
             Time {
                 seconds: 1112911993,
                 offset: 3600,
-                sign: Sign::Plus,
             },
             "1112911993 +0100",
         ),
@@ -86,7 +85,6 @@ fn time() -> Time {
     Time {
         seconds: 123456789,
         offset: 9000,
-        sign: Sign::Plus,
     }
 }
 
@@ -94,6 +92,5 @@ fn time_dec1() -> Time {
     Time {
         seconds: 123543189,
         offset: 9000,
-        sign: Sign::Plus,
     }
 }
diff --git a/gix-date/tests/time/mod.rs b/gix-date/tests/time/mod.rs
index 82f1f37a81e..de34bc52fa7 100644
--- a/gix-date/tests/time/mod.rs
+++ b/gix-date/tests/time/mod.rs
@@ -3,23 +3,6 @@ use gix_date::Time;
 mod baseline;
 mod format;
 mod parse;
-mod init {
-    use gix_date::Time;
-
-    #[test]
-    fn utc_local_handles_signs_correctly() {
-        for time in [
-            Time::now_local_or_utc(),
-            Time::now_local().unwrap_or_else(Time::now_utc),
-        ] {
-            assert_eq!(
-                time.sign,
-                time.offset.into(),
-                "the sign matches the sign of the date offset"
-            );
-        }
-    }
-}
 
 #[test]
 fn is_set() {
@@ -33,15 +16,13 @@ fn is_set() {
 
 mod write_to {
     use bstr::ByteSlice;
-    use gix_date::time::Sign;
-    use gix_date::{SecondsSinceUnixEpoch, Time};
+    use gix_date::{parse::TimeBuf, SecondsSinceUnixEpoch, Time};
 
     #[test]
     fn invalid() {
         let time = Time {
             seconds: 0,
             offset: (100 * 60 * 60) + 30 * 60,
-            sign: Sign::Plus,
         };
         let err = time.write_to(&mut Vec::new()).unwrap_err();
         assert_eq!(err.to_string(), "Cannot represent offsets larger than +-9900");
@@ -54,23 +35,20 @@ mod write_to {
                 Time {
                     seconds: SecondsSinceUnixEpoch::MAX,
                     offset: 0,
-                    sign: Sign::Minus,
                 },
-                "9223372036854775807 -0000",
+                "9223372036854775807 +0000",
             ),
             (
                 Time {
                     seconds: SecondsSinceUnixEpoch::MIN,
                     offset: 0,
-                    sign: Sign::Minus,
                 },
-                "-9223372036854775808 -0000",
+                "-9223372036854775808 +0000",
             ),
             (
                 Time {
                     seconds: 500,
                     offset: 9000,
-                    sign: Sign::Plus,
                 },
                 "500 +0230",
             ),
@@ -78,23 +56,14 @@ mod write_to {
                 Time {
                     seconds: 189009009,
                     offset: -36000,
-                    sign: Sign::Minus,
                 },
                 "189009009 -1000",
             ),
-            (
-                Time {
-                    seconds: 0,
-                    offset: 0,
-                    sign: Sign::Minus,
-                },
-                "0 -0000",
-            ),
+            (Time { seconds: 0, offset: 0 }, "0 +0000"),
             (
                 Time {
                     seconds: 0,
                     offset: -24 * 60 * 60,
-                    sign: Sign::Minus,
                 },
                 "0 -2400",
             ),
@@ -102,7 +71,6 @@ mod write_to {
                 Time {
                     seconds: 0,
                     offset: 24 * 60 * 60,
-                    sign: Sign::Plus,
                 },
                 "0 +2400",
             ),
@@ -110,7 +78,6 @@ mod write_to {
                 Time {
                     seconds: 0,
                     offset: (25 * 60 * 60) + 30 * 60,
-                    sign: Sign::Plus,
                 },
                 "0 +2530",
             ),
@@ -118,7 +85,6 @@ mod write_to {
                 Time {
                     seconds: 0,
                     offset: (-25 * 60 * 60) - 30 * 60,
-                    sign: Sign::Minus,
                 },
                 "0 -2530",
             ),
@@ -126,7 +92,6 @@ mod write_to {
                 Time {
                     seconds: 0,
                     offset: (99 * 60 * 60) + 59 * 60,
-                    sign: Sign::Plus,
                 },
                 "0 +9959",
             ),
@@ -141,4 +106,17 @@ mod write_to {
         }
         Ok(())
     }
+
+    #[test]
+    fn max() -> gix_testtools::Result {
+        let mut buf = TimeBuf::default();
+        Time::MAX.write_to(&mut buf)?;
+        assert_eq!(Time::MAX.size(), 25, "The largest possible serialized size");
+
+        let expected = "9223372036854775807 +9959";
+        assert_eq!(buf.as_str(), expected);
+        assert_eq!(buf.as_str().len(), Time::MAX.size());
+        assert_eq!(Time::MAX.to_str(&mut buf), expected);
+        Ok(())
+    }
 }
diff --git a/gix-date/tests/time/parse.rs b/gix-date/tests/time/parse.rs
index 44222752e8c..c10db9f91aa 100644
--- a/gix-date/tests/time/parse.rs
+++ b/gix-date/tests/time/parse.rs
@@ -1,6 +1,6 @@
 use std::time::SystemTime;
 
-use gix_date::{time::Sign, Time};
+use gix_date::Time;
 
 #[test]
 fn special_time_is_ok_for_now() {
@@ -9,7 +9,6 @@ fn special_time_is_ok_for_now() {
         Time {
             seconds: 42,
             offset: 1800,
-            sign: Sign::Plus,
         }
     );
 }
@@ -21,7 +20,6 @@ fn short() {
         Time {
             seconds: 288835200,
             offset: 0,
-            sign: Sign::Plus,
         },
         "could not parse with SHORT format"
     );
@@ -34,7 +32,6 @@ fn rfc2822() {
         Time {
             seconds: 1660797906,
             offset: 28800,
-            sign: Sign::Plus,
         },
     );
 }
@@ -44,7 +41,6 @@ fn git_rfc2822() {
     let expected = Time {
         seconds: 1659329106,
         offset: 28800,
-        sign: Sign::Plus,
     };
     assert_eq!(
         gix_date::parse("Thu, 1 Aug 2022 12:45:06 +0800", None).unwrap(),
@@ -57,29 +53,43 @@ fn git_rfc2822() {
 }
 
 #[test]
-fn raw() {
+fn raw() -> gix_testtools::Result {
     assert_eq!(
-        gix_date::parse("1660874655 +0800", None).unwrap(),
+        gix_date::parse("1660874655 +0800", None)?,
         Time {
             seconds: 1660874655,
             offset: 28800,
-            sign: Sign::Plus,
         },
     );
 
     assert_eq!(
-        gix_date::parse("1112911993 +0100", None).unwrap(),
+        gix_date::parse("1112911993 +0100", None)?,
         Time {
             seconds: 1112911993,
             offset: 3600,
-            sign: Sign::Plus,
+        },
+    );
+
+    assert_eq!(
+        gix_date::parse("1313584730 +051800", None)?,
+        Time {
+            seconds: 1313584730,
+            offset: 19080,
+        },
+        "seconds for time-offsets work as well"
+    );
+
+    assert_eq!(
+        gix_date::parse("1313584730 +051842", None)?,
+        Time {
+            seconds: 1313584730,
+            offset: 19122,
         },
     );
 
     let expected = Time {
         seconds: 1660874655,
         offset: -28800,
-        sign: Sign::Minus,
     };
     for date_str in [
         "1660874655 -0800",
@@ -88,9 +98,11 @@ fn raw() {
         "  1660874655 -0800  ",
         "  1660874655  -0800  ",
         "1660874655\t-0800",
+        "1660874655\t-080000",
     ] {
-        assert_eq!(gix_date::parse(date_str, None).unwrap(), expected);
+        assert_eq!(gix_date::parse_header(date_str), Some(expected));
     }
+    Ok(())
 }
 
 #[test]
@@ -107,27 +119,33 @@ fn bad_raw() {
         "123456+0600",
         "123456 + 600",
     ] {
-        assert!(gix_date::parse(bad_date_str, None).is_err());
+        assert_eq!(
+            gix_date::parse_header(bad_date_str),
+            Some(Time {
+                seconds: 123456,
+                offset: 0
+            }),
+            "{bad_date_str}: invalid offsets default to zero (like in git2), and Git ignores them mostly"
+        );
     }
 }
 
 #[test]
 fn double_negation_in_offset() {
-    let actual = gix_date::parse("1288373970 --700", None).unwrap();
+    let actual = gix_date::parse_header("1288373970 --700").unwrap();
     assert_eq!(
         actual,
         gix_date::Time {
             seconds: 1288373970,
-            offset: 25200,
-            sign: Sign::Minus,
+            offset: 0,
         },
-        "double-negation stays negative, and is parseable."
+        "double-negation isn't special, it's considered malformed"
     );
 
     assert_eq!(
-        actual.to_bstring(),
-        "1288373970 -0700",
-        "serialization corrects the issue"
+        actual.to_string(),
+        "1288373970 +0000",
+        "serialization is lossy as offset couldn't be parsed"
     );
 }
 
@@ -138,7 +156,6 @@ fn git_default() {
         Time {
             seconds: 1659933906,
             offset: 28800,
-            sign: Sign::Plus,
         },
     );
 }
@@ -154,7 +171,6 @@ fn invalid_dates_can_be_produced_without_current_time() {
 mod relative {
     use std::time::SystemTime;
 
-    use gix_date::time::Sign;
     use jiff::{ToSpan, Zoned};
     use pretty_assertions::assert_eq;
 
@@ -180,8 +196,6 @@ mod relative {
     #[test]
     fn various() {
         let now = SystemTime::now();
-
-        // For comparison, a few are the same as in: https://github.com/git/git/blob/master/t/t0006-date.sh
         let cases = [
             ("5 seconds ago", 5.seconds()),
             ("12345 florx ago", 12_345.seconds()), // Anything parses as seconds
@@ -227,11 +241,6 @@ mod relative {
             let time = gix_date::parse(input, Some(now)).expect("relative time string should parse to a Time");
             (input, time)
         });
-        assert_eq!(
-            cases_with_times.map(|(_, time)| time.sign),
-            cases_with_times.map(|_| Sign::Plus),
-            "Despite being in the past, the dates produced are positive, as they are still post-epoch"
-        );
         assert_eq!(
             cases_with_times.map(|(_, time)| time.offset),
             cases_with_times.map(|_| 0),
@@ -264,6 +273,55 @@ mod relative {
         });
         assert_eq!(actual, expected);
     }
+
+    #[test]
+    fn various_examples() {
+        #[rustfmt::skip]
+        let expected = [
+        // ### 1. SHORT Format
+            "2018-12-24",
+            "1950-01-01",
+            "1970-01-01",
+            "2024-12-31",
+
+        // ### 2. RFC2822 Format
+            "Thu, 18 Aug 2022 12:45:06 +0800",
+            "Mon Oct 27 10:30:00 2023 -0800",
+
+        // ### 3. GIT_RFC2822 Format
+            "Thu, 8 Aug 2022 12:45:06 +0800",
+            "Mon Oct 27 10:30:00 2023 -0800",
+
+        // ### 4. ISO8601 Format
+            "2022-08-17 22:04:58 +0200",
+            "1970-01-01 00:00:00 -0500",
+
+        // ### 5. ISO8601_STRICT Format
+            "2022-08-17T21:43:13+08:00",
+
+        // ### 6. UNIX Timestamp (Seconds Since Epoch)
+            "123456789",
+            "0",
+            "-100",
+            "1700000000",
+
+
+        // ### 7. RAW Format
+            "1745582210 +0200",
+            "1660874655 +0800",
+            "-1660874655 +0800",
+        // ### 8. GITOXIDE Format
+            "Thu Sep 04 2022 10:45:06 -0400",
+            "Mon Oct 27 2023 10:30:00 +0000",
+        // ### 9. DEFAULT Format
+            "Thu Sep 4 10:45:06 2022 -0400",
+            "Mon Oct 27 10:30:00 2023 +0000",
+        ];
+        for date in expected {
+            _ = gix_date::parse(date, None)
+                .unwrap_or_else(|err| unreachable!("{date}: all examples can be parsed: {err}"));
+        }
+    }
 }
 
 /// Various cases the fuzzer found
@@ -271,7 +329,7 @@ mod fuzz {
     #[test]
     fn invalid_but_does_not_cause_panic() {
         for input in ["-9999-1-1", "7	-𬞋", "5 ڜ-09", "-4 week ago Z", "8960609 day ago"] {
-            let _ = gix_date::parse(input, Some(std::time::UNIX_EPOCH)).unwrap_err();
+            gix_date::parse(input, Some(std::time::UNIX_EPOCH)).ok();
         }
     }
 }
diff --git a/gix-diff/src/blob/platform.rs b/gix-diff/src/blob/platform.rs
index 163f2678f71..1907319b54d 100644
--- a/gix-diff/src/blob/platform.rs
+++ b/gix-diff/src/blob/platform.rs
@@ -1,6 +1,6 @@
+use std::{cmp::Ordering, io::Write, process::Stdio};
+
 use bstr::{BStr, BString, ByteSlice};
-use std::cmp::Ordering;
-use std::{io::Write, process::Stdio};
 
 use super::Algorithm;
 use crate::blob::{pipeline, Pipeline, Platform, ResourceKind};
@@ -213,9 +213,10 @@ pub mod set_resource {
 
 ///
 pub mod prepare_diff {
-    use crate::blob::platform::Resource;
     use bstr::BStr;
 
+    use crate::blob::platform::Resource;
+
     /// The kind of operation that should be performed based on the configuration of the resources involved in the diff.
     #[derive(Debug, Copy, Clone, Eq, PartialEq)]
     pub enum Operation<'a> {
diff --git a/gix-diff/src/blob/unified_diff.rs b/gix-diff/src/blob/unified_diff.rs
index 8eac3f4d8d2..e0870d2eb0b 100644
--- a/gix-diff/src/blob/unified_diff.rs
+++ b/gix-diff/src/blob/unified_diff.rs
@@ -69,13 +69,13 @@ pub trait ConsumeHunk {
 }
 
 pub(super) mod _impl {
-    use super::{ConsumeHunk, ContextSize, NewlineSeparator};
+    use std::{hash::Hash, io::ErrorKind, ops::Range};
+
     use bstr::{ByteSlice, ByteVec};
     use imara_diff::{intern, Sink};
     use intern::{InternedInput, Interner, Token};
-    use std::hash::Hash;
-    use std::io::ErrorKind;
-    use std::ops::Range;
+
+    use super::{ConsumeHunk, ContextSize, NewlineSeparator};
 
     /// A [`Sink`] that creates a textual diff in the format typically output by git or `gnu-diff` if the `-u` option is used,
     /// and passes it in full to a consumer.
diff --git a/gix-diff/src/index/change.rs b/gix-diff/src/index/change.rs
index 5ce52990b8c..923e80dee2e 100644
--- a/gix-diff/src/index/change.rs
+++ b/gix-diff/src/index/change.rs
@@ -1,10 +1,14 @@
-use crate::index::{Change, ChangeRef};
-use crate::rewrites;
-use crate::rewrites::tracker::ChangeKind;
-use crate::tree::visit::Relation;
+use std::borrow::Cow;
+
 use bstr::BStr;
 use gix_object::tree;
-use std::borrow::Cow;
+
+use crate::{
+    index::{Change, ChangeRef},
+    rewrites,
+    rewrites::tracker::ChangeKind,
+    tree::visit::Relation,
+};
 
 impl ChangeRef<'_, '_> {
     /// Copy everything into an owned version of this instance.
diff --git a/gix-diff/src/index/function.rs b/gix-diff/src/index/function.rs
index 28f8101da51..a24b67184ac 100644
--- a/gix-diff/src/index/function.rs
+++ b/gix-diff/src/index/function.rs
@@ -1,10 +1,10 @@
-use super::{Action, ChangeRef, Error, RewriteOptions};
-use crate::rewrites;
+use std::{borrow::Cow, cell::RefCell, cmp::Ordering};
+
 use bstr::BStr;
 use gix_filter::attributes::glob::pattern::Case;
-use std::borrow::Cow;
-use std::cell::RefCell;
-use std::cmp::Ordering;
+
+use super::{Action, ChangeRef, Error, RewriteOptions};
+use crate::rewrites;
 
 /// Produce an entry-by-entry diff between `lhs` and `rhs`, sending changes to `cb(change) -> Action` for consumption,
 /// which would turn `lhs` into `rhs` if applied.
diff --git a/gix-diff/src/index/mod.rs b/gix-diff/src/index/mod.rs
index 67dbe07a812..b2843942423 100644
--- a/gix-diff/src/index/mod.rs
+++ b/gix-diff/src/index/mod.rs
@@ -1,6 +1,7 @@
-use bstr::BStr;
 use std::borrow::Cow;
 
+use bstr::BStr;
+
 /// The error returned by [`index()`](crate::index()).
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-diff/src/rewrites/mod.rs b/gix-diff/src/rewrites/mod.rs
index 85a3704b6ae..f3db10ddff0 100644
--- a/gix-diff/src/rewrites/mod.rs
+++ b/gix-diff/src/rewrites/mod.rs
@@ -1,7 +1,7 @@
-use crate::tree::visit::ChangeId;
-use crate::Rewrites;
 use std::collections::BTreeSet;
 
+use crate::{tree::visit::ChangeId, Rewrites};
+
 /// Types related to the rename tracker for renames, rewrites and copies.
 pub mod tracker;
 
diff --git a/gix-diff/src/rewrites/tracker.rs b/gix-diff/src/rewrites/tracker.rs
index 267fbd450b4..dc2d10cb077 100644
--- a/gix-diff/src/rewrites/tracker.rs
+++ b/gix-diff/src/rewrites/tracker.rs
@@ -10,11 +10,10 @@ use std::ops::Range;
 use bstr::{BStr, ByteSlice};
 use gix_object::tree::{EntryKind, EntryMode};
 
-use crate::rewrites::tracker::visit::SourceKind;
-use crate::tree::visit::{Action, ChangeId, Relation};
 use crate::{
     blob::{platform::prepare_diff::Operation, DiffLineStats, ResourceKind},
-    rewrites::{CopySource, Outcome, Tracker},
+    rewrites::{tracker::visit::SourceKind, CopySource, Outcome, Tracker},
+    tree::visit::{Action, ChangeId, Relation},
     Rewrites,
 };
 
diff --git a/gix-diff/src/tree/function.rs b/gix-diff/src/tree/function.rs
index 634cb07aa49..4d3452dddb0 100644
--- a/gix-diff/src/tree/function.rs
+++ b/gix-diff/src/tree/function.rs
@@ -2,8 +2,10 @@ use std::{borrow::BorrowMut, collections::VecDeque};
 
 use gix_object::{tree::EntryRef, FindExt, TreeRefIter};
 
-use crate::tree::visit::{ChangeId, Relation};
-use crate::tree::{visit::Change, Error, State, TreeInfoTuple, Visit};
+use crate::tree::{
+    visit::{Change, ChangeId, Relation},
+    Error, State, TreeInfoTuple, Visit,
+};
 
 /// Calculate the changes that would need to be applied to `lhs` to get `rhs` using `objects` to obtain objects as needed for traversal.
 /// `state` can be used between multiple calls to re-use memory.
diff --git a/gix-diff/src/tree/mod.rs b/gix-diff/src/tree/mod.rs
index d542b1c1239..ed9157b4228 100644
--- a/gix-diff/src/tree/mod.rs
+++ b/gix-diff/src/tree/mod.rs
@@ -1,8 +1,10 @@
-use crate::tree::visit::Relation;
+use std::collections::VecDeque;
+
 use bstr::BStr;
 use gix_hash::ObjectId;
 use gix_object::bstr::BString;
-use std::collections::VecDeque;
+
+use crate::tree::visit::Relation;
 
 /// The error returned by [`tree()`](super::tree()).
 #[derive(Debug, thiserror::Error)]
diff --git a/gix-diff/src/tree/recorder.rs b/gix-diff/src/tree/recorder.rs
index 9a3783447b9..0dcd9b0ac64 100644
--- a/gix-diff/src/tree/recorder.rs
+++ b/gix-diff/src/tree/recorder.rs
@@ -4,8 +4,7 @@ use gix_object::{
     tree,
 };
 
-use crate::tree::visit::Relation;
-use crate::tree::{visit, Recorder, Visit};
+use crate::tree::{visit, visit::Relation, Recorder, Visit};
 
 /// Describe how to track the location of a change.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
diff --git a/gix-diff/src/tree/visit.rs b/gix-diff/src/tree/visit.rs
index cf8030e748c..f76248ed4d5 100644
--- a/gix-diff/src/tree/visit.rs
+++ b/gix-diff/src/tree/visit.rs
@@ -110,8 +110,10 @@ mod change_impls {
     use gix_hash::oid;
     use gix_object::tree::EntryMode;
 
-    use crate::tree::visit::Relation;
-    use crate::{rewrites::tracker::ChangeKind, tree::visit::Change};
+    use crate::{
+        rewrites::tracker::ChangeKind,
+        tree::visit::{Change, Relation},
+    };
 
     impl crate::rewrites::tracker::Change for crate::tree::visit::Change {
         fn id(&self) -> &oid {
diff --git a/gix-diff/src/tree_with_rewrites/change.rs b/gix-diff/src/tree_with_rewrites/change.rs
index 76749090126..b613e203942 100644
--- a/gix-diff/src/tree_with_rewrites/change.rs
+++ b/gix-diff/src/tree_with_rewrites/change.rs
@@ -1,7 +1,9 @@
-use crate::blob::{DiffLineStats, ResourceKind};
-use crate::tree;
-use bstr::BString;
-use bstr::{BStr, ByteSlice};
+use bstr::{BStr, BString, ByteSlice};
+
+use crate::{
+    blob::{DiffLineStats, ResourceKind},
+    tree,
+};
 
 /// Represents any possible change in order to turn one tree into another, which references data owned by its producer.
 #[derive(Debug, Clone, Copy, PartialEq)]
diff --git a/gix-diff/src/tree_with_rewrites/function.rs b/gix-diff/src/tree_with_rewrites/function.rs
index df0b0be1a32..da6454dfd91 100644
--- a/gix-diff/src/tree_with_rewrites/function.rs
+++ b/gix-diff/src/tree_with_rewrites/function.rs
@@ -2,8 +2,7 @@ use bstr::BStr;
 use gix_object::TreeRefIter;
 
 use super::{Action, ChangeRef, Error, Options};
-use crate::rewrites;
-use crate::rewrites::tracker;
+use crate::{rewrites, rewrites::tracker};
 
 /// Call `for_each` repeatedly with all changes that are needed to convert `lhs` to `rhs`.
 /// Provide a `resource_cache` to speed up obtaining blobs for similarity checks.
@@ -215,10 +214,10 @@ where
 }
 
 mod tree_to_changes {
-    use crate::tree::visit::Change;
+    use bstr::BStr;
     use gix_object::tree::EntryRef;
 
-    use bstr::BStr;
+    use crate::tree::visit::Change;
 
     pub struct Delegate<'a> {
         push: &'a mut dyn FnMut(Change, &BStr),
diff --git a/gix-diff/src/tree_with_rewrites/mod.rs b/gix-diff/src/tree_with_rewrites/mod.rs
index 855eb082e39..c85221c47de 100644
--- a/gix-diff/src/tree_with_rewrites/mod.rs
+++ b/gix-diff/src/tree_with_rewrites/mod.rs
@@ -1,5 +1,4 @@
-use crate::tree::recorder::Location;
-use crate::Rewrites;
+use crate::{tree::recorder::Location, Rewrites};
 
 mod change;
 pub use change::{Change, ChangeRef};
diff --git a/gix-diff/tests/diff/blob/unified_diff.rs b/gix-diff/tests/diff/blob/unified_diff.rs
index 4bc8a385169..db5cd9106b5 100644
--- a/gix-diff/tests/diff/blob/unified_diff.rs
+++ b/gix-diff/tests/diff/blob/unified_diff.rs
@@ -1,5 +1,7 @@
-use gix_diff::blob::unified_diff::{ConsumeHunk, ContextSize, NewlineSeparator};
-use gix_diff::blob::{Algorithm, UnifiedDiff};
+use gix_diff::blob::{
+    unified_diff::{ConsumeHunk, ContextSize, NewlineSeparator},
+    Algorithm, UnifiedDiff,
+};
 
 #[test]
 fn removed_modified_added() -> crate::Result {
diff --git a/gix-diff/tests/diff/index.rs b/gix-diff/tests/diff/index.rs
index 746aa04bf7a..f38c30f14df 100644
--- a/gix-diff/tests/diff/index.rs
+++ b/gix-diff/tests/diff/index.rs
@@ -1,6 +1,8 @@
-use gix_diff::index::Change;
-use gix_diff::rewrites::{Copies, CopySource};
-use gix_diff::Rewrites;
+use gix_diff::{
+    index::Change,
+    rewrites::{Copies, CopySource},
+    Rewrites,
+};
 use gix_object::bstr::BStr;
 
 #[test]
@@ -1211,9 +1213,12 @@ fn unmerged_entries_and_intent_to_add() -> crate::Result {
 }
 
 mod util {
+    use std::{
+        convert::Infallible,
+        path::{Path, PathBuf},
+    };
+
     use gix_diff::rewrites;
-    use std::convert::Infallible;
-    use std::path::{Path, PathBuf};
 
     fn repo_workdir() -> crate::Result<PathBuf> {
         gix_testtools::scripted_fixture_read_only_standalone("make_diff_for_rewrites_repo.sh")
@@ -1321,5 +1326,6 @@ mod util {
         }
     }
 }
-use crate::hex_to_id;
 use util::{collect_changes_no_renames, collect_changes_opts, collect_changes_opts_with_pathspec, repo_with_indices};
+
+use crate::hex_to_id;
diff --git a/gix-diff/tests/diff/rewrites/mod.rs b/gix-diff/tests/diff/rewrites/mod.rs
index c5b152c3245..cbad0fc5647 100644
--- a/gix-diff/tests/diff/rewrites/mod.rs
+++ b/gix-diff/tests/diff/rewrites/mod.rs
@@ -1,5 +1,7 @@
-use gix_diff::rewrites::tracker::ChangeKind;
-use gix_diff::tree::visit::{ChangeId, Relation};
+use gix_diff::{
+    rewrites::tracker::ChangeKind,
+    tree::visit::{ChangeId, Relation},
+};
 use gix_hash::{oid, ObjectId};
 use gix_object::tree::{EntryKind, EntryMode};
 
diff --git a/gix-diff/tests/diff/rewrites/tracker.rs b/gix-diff/tests/diff/rewrites/tracker.rs
index 9469494e89a..5756d8f1d37 100644
--- a/gix-diff/tests/diff/rewrites/tracker.rs
+++ b/gix-diff/tests/diff/rewrites/tracker.rs
@@ -1,8 +1,3 @@
-use crate::{
-    hex_to_id,
-    rewrites::{Change, NULL_ID},
-};
-use gix_diff::tree::visit::Relation;
 use gix_diff::{
     blob::DiffLineStats,
     rewrites,
@@ -13,12 +8,17 @@ use gix_diff::{
         },
         Copies, CopySource,
     },
-    tree::visit::Action,
+    tree::visit::{Action, Relation},
     Rewrites,
 };
 use gix_object::tree::EntryKind;
 use pretty_assertions::assert_eq;
 
+use crate::{
+    hex_to_id,
+    rewrites::{Change, NULL_ID},
+};
+
 #[test]
 fn rename_by_id() -> crate::Result {
     // Limits are only applied when doing rewrite-checks
diff --git a/gix-diff/tests/diff/tree.rs b/gix-diff/tests/diff/tree.rs
index 19ba1632387..ad019d58b19 100644
--- a/gix-diff/tests/diff/tree.rs
+++ b/gix-diff/tests/diff/tree.rs
@@ -2,10 +2,10 @@ mod changes {
     mod to_obtain_tree {
         use std::collections::HashMap;
 
-        use gix_diff::tree::visit::Relation;
         use gix_diff::tree::{
             recorder,
             recorder::{Change::*, Location},
+            visit::Relation,
         };
         use gix_hash::{oid, ObjectId};
         use gix_object::{bstr::ByteSlice, tree::EntryKind, TreeRefIter};
diff --git a/gix-diff/tests/diff/tree_with_rewrites.rs b/gix-diff/tests/diff/tree_with_rewrites.rs
index 34186ec543f..af5bacf95d6 100644
--- a/gix-diff/tests/diff/tree_with_rewrites.rs
+++ b/gix-diff/tests/diff/tree_with_rewrites.rs
@@ -1,10 +1,10 @@
-use gix_diff::rewrites::{Copies, CopySource};
-use gix_diff::tree::recorder::Location;
-use gix_diff::tree::visit::Relation;
-use gix_diff::tree_with_rewrites::{Change, Options};
-use gix_diff::Rewrites;
-use gix_object::bstr::BStr;
-use gix_object::TreeRefIter;
+use gix_diff::{
+    rewrites::{Copies, CopySource},
+    tree::{recorder::Location, visit::Relation},
+    tree_with_rewrites::{Change, Options},
+    Rewrites,
+};
+use gix_object::{bstr::BStr, TreeRefIter};
 
 #[test]
 fn empty_to_new_tree_without_rename_tracking() -> crate::Result {
@@ -1788,10 +1788,13 @@ fn realistic_renames_3_without_identity() -> crate::Result {
 }
 
 mod util {
+    use std::{
+        convert::Infallible,
+        path::{Path, PathBuf},
+    };
+
     use gix_diff::rewrites;
     use gix_object::{FindExt, TreeRefIter};
-    use std::convert::Infallible;
-    use std::path::{Path, PathBuf};
 
     pub fn repo_workdir() -> crate::Result<PathBuf> {
         gix_testtools::scripted_fixture_read_only_standalone("make_diff_for_rewrites_repo.sh")
diff --git a/gix-dir/src/entry.rs b/gix-dir/src/entry.rs
index 690be589ff2..d01958c3cb7 100644
--- a/gix-dir/src/entry.rs
+++ b/gix-dir/src/entry.rs
@@ -1,7 +1,6 @@
-use crate::walk::ForDeletionMode;
-use crate::{Entry, EntryRef};
-use std::borrow::Cow;
-use std::fs::FileType;
+use std::{borrow::Cow, fs::FileType};
+
+use crate::{walk::ForDeletionMode, Entry, EntryRef};
 
 /// A way of attaching additional information to an [Entry] .
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
diff --git a/gix-dir/src/lib.rs b/gix-dir/src/lib.rs
index 5c099a730d9..e75a724791c 100644
--- a/gix-dir/src/lib.rs
+++ b/gix-dir/src/lib.rs
@@ -2,9 +2,10 @@
 #![deny(missing_docs, rust_2018_idioms)]
 #![forbid(unsafe_code)]
 
-use bstr::{BStr, BString};
 use std::borrow::Cow;
 
+use bstr::{BStr, BString};
+
 /// A directory entry, typically obtained using [`walk()`].
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct EntryRef<'a> {
diff --git a/gix-dir/src/walk/classify.rs b/gix-dir/src/walk/classify.rs
index 9ffa6522312..86ad34f37ba 100644
--- a/gix-dir/src/walk/classify.rs
+++ b/gix-dir/src/walk/classify.rs
@@ -1,10 +1,16 @@
-use crate::{entry, Entry, EntryRef};
-use std::borrow::Cow;
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+};
 
-use crate::entry::PathspecMatch;
-use crate::walk::{Context, Error, ForDeletionMode, Options};
 use bstr::{BStr, BString, ByteSlice};
-use std::path::{Path, PathBuf};
+
+use crate::{
+    entry,
+    entry::PathspecMatch,
+    walk::{Context, Error, ForDeletionMode, Options},
+    Entry, EntryRef,
+};
 
 /// Classify the `worktree_relative_root` path and return the first `PathKind` that indicates that
 /// it isn't a directory, leaving `buf` with the path matching the returned `PathKind`,
diff --git a/gix-dir/src/walk/function.rs b/gix-dir/src/walk/function.rs
index 65f8f8d1b73..9cbda0965ad 100644
--- a/gix-dir/src/walk/function.rs
+++ b/gix-dir/src/walk/function.rs
@@ -1,10 +1,15 @@
-use std::borrow::Cow;
-use std::path::{Path, PathBuf};
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+};
 
 use bstr::{BStr, BString, ByteSlice};
 
-use crate::walk::{classify, readdir, Action, Context, Delegate, Error, ForDeletionMode, Options, Outcome};
-use crate::{entry, EntryRef};
+use crate::{
+    entry,
+    walk::{classify, readdir, Action, Context, Delegate, Error, ForDeletionMode, Options, Outcome},
+    EntryRef,
+};
 
 /// A function to perform a git-style, unsorted, directory walk.
 ///
diff --git a/gix-dir/src/walk/mod.rs b/gix-dir/src/walk/mod.rs
index ab26b31e31a..49951f98fab 100644
--- a/gix-dir/src/walk/mod.rs
+++ b/gix-dir/src/walk/mod.rs
@@ -1,8 +1,8 @@
-use crate::{entry, EntryRef};
+use std::{collections::BTreeSet, path::PathBuf, sync::atomic::AtomicBool};
+
 use bstr::{BStr, BString};
-use std::collections::BTreeSet;
-use std::path::PathBuf;
-use std::sync::atomic::AtomicBool;
+
+use crate::{entry, EntryRef};
 
 /// A type returned by the [`Delegate::emit()`] as passed to [`walk()`](function::walk()).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -16,8 +16,7 @@ pub enum Action {
 
 /// Ready-made delegate implementations.
 pub mod delegate {
-    use crate::walk::Action;
-    use crate::{entry, walk, Entry, EntryRef};
+    use crate::{entry, walk, walk::Action, Entry, EntryRef};
 
     type Entries = Vec<(Entry, Option<entry::Status>)>;
 
diff --git a/gix-dir/src/walk/readdir.rs b/gix-dir/src/walk/readdir.rs
index 9c6de3f97bf..1d4f04e09f9 100644
--- a/gix-dir/src/walk/readdir.rs
+++ b/gix-dir/src/walk/readdir.rs
@@ -1,15 +1,24 @@
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+    sync::atomic::Ordering,
+};
+
 use bstr::{BStr, BString, ByteSlice};
-use std::borrow::Cow;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::Ordering;
 
-use crate::entry::{PathspecMatch, Status};
-use crate::walk::function::{can_recurse, emit_entry};
-use crate::walk::EmissionMode::CollapseDirectory;
-use crate::walk::{
-    classify, Action, CollapsedEntriesEmissionMode, Context, Delegate, Error, ForDeletionMode, Options, Outcome,
+use crate::{
+    entry,
+    entry::{PathspecMatch, Status},
+    walk,
+    walk::{
+        classify,
+        function::{can_recurse, emit_entry},
+        Action, CollapsedEntriesEmissionMode, Context, Delegate,
+        EmissionMode::CollapseDirectory,
+        Error, ForDeletionMode, Options, Outcome,
+    },
+    Entry, EntryRef,
 };
-use crate::{entry, walk, Entry, EntryRef};
 
 /// ### Deviation
 ///
diff --git a/gix-dir/tests/dir/walk.rs b/gix-dir/tests/dir/walk.rs
index f27e58bfe2d..515c282c187 100644
--- a/gix-dir/tests/dir/walk.rs
+++ b/gix-dir/tests/dir/walk.rs
@@ -1,22 +1,24 @@
-use gix_dir::{walk, EntryRef};
+use std::{collections::BTreeSet, sync::atomic::AtomicBool};
+
+use gix_dir::{
+    entry,
+    entry::{Kind::*, PathspecMatch::*, Property::*, Status::*},
+    walk,
+    walk::{
+        CollapsedEntriesEmissionMode::{All, OnStatusMismatch},
+        EmissionMode::*,
+        ForDeletionMode,
+    },
+    EntryRef,
+};
+use gix_ignore::Kind::*;
 use pretty_assertions::assert_eq;
-use std::collections::BTreeSet;
-use std::sync::atomic::AtomicBool;
 
 use crate::walk_utils::{
     collect, collect_filtered, collect_filtered_with_cwd, entry, entry_dirstat, entry_nokind, entry_nomatch, entryps,
     entryps_dirstat, fixture, fixture_in, options, options_emit_all, try_collect, try_collect_filtered_opts,
     try_collect_filtered_opts_collect, try_collect_filtered_opts_collect_with_root, EntryExt, Options,
 };
-use gix_dir::entry;
-use gix_dir::entry::Kind::*;
-use gix_dir::entry::PathspecMatch::*;
-use gix_dir::entry::Property::*;
-use gix_dir::entry::Status::*;
-use gix_dir::walk::CollapsedEntriesEmissionMode::{All, OnStatusMismatch};
-use gix_dir::walk::EmissionMode::*;
-use gix_dir::walk::ForDeletionMode;
-use gix_ignore::Kind::*;
 
 #[test]
 #[cfg(unix)]
diff --git a/gix-dir/tests/dir_cwd.rs b/gix-dir/tests/dir_cwd.rs
index a05c35d28ca..6b01b74501a 100644
--- a/gix-dir/tests/dir_cwd.rs
+++ b/gix-dir/tests/dir_cwd.rs
@@ -1,11 +1,13 @@
-use crate::walk_utils::{collect, entryps, fixture, options};
-use gix_dir::entry::Kind::File;
-use gix_dir::entry::PathspecMatch::Prefix;
-use gix_dir::entry::Status::Untracked;
-use gix_dir::walk;
-use pretty_assertions::assert_eq;
 use std::path::Path;
 
+use gix_dir::{
+    entry::{Kind::File, PathspecMatch::Prefix, Status::Untracked},
+    walk,
+};
+use pretty_assertions::assert_eq;
+
+use crate::walk_utils::{collect, entryps, fixture, options};
+
 pub mod walk_utils;
 
 #[test]
diff --git a/gix-dir/tests/walk_utils/mod.rs b/gix-dir/tests/walk_utils/mod.rs
index 37b5d12a80d..cbf61634249 100644
--- a/gix-dir/tests/walk_utils/mod.rs
+++ b/gix-dir/tests/walk_utils/mod.rs
@@ -1,8 +1,11 @@
+use std::{
+    path::{Path, PathBuf},
+    sync::atomic::AtomicBool,
+};
+
 use bstr::BStr;
 use gix_dir::{entry, walk, Entry};
 use gix_testtools::scripted_fixture_read_only;
-use std::path::{Path, PathBuf};
-use std::sync::atomic::AtomicBool;
 
 pub fn fixture_in(filename: &str, name: &str) -> PathBuf {
     let root = scripted_fixture_read_only(format!("{filename}.sh")).expect("script works");
diff --git a/gix-discover/src/is.rs b/gix-discover/src/is.rs
index 5c88db3a1f5..ba18cfaa3b6 100644
--- a/gix-discover/src/is.rs
+++ b/gix-discover/src/is.rs
@@ -1,6 +1,7 @@
-use crate::{DOT_GIT_DIR, MODULES};
 use std::{borrow::Cow, ffi::OsStr, path::Path};
 
+use crate::{DOT_GIT_DIR, MODULES};
+
 /// Returns true if the given `git_dir` seems to be a bare repository.
 ///
 /// Please note that repositories without an index generally _look_ bare, even though they might also be uninitialized.
diff --git a/gix-features/src/fs.rs b/gix-features/src/fs.rs
index 5fc1a62021b..1838dcdbd87 100644
--- a/gix-features/src/fs.rs
+++ b/gix-features/src/fs.rs
@@ -22,9 +22,7 @@ mod shared {
 
 #[cfg(any(feature = "walkdir", feature = "fs-read-dir"))]
 mod walkdir_precompose {
-    use std::borrow::Cow;
-    use std::ffi::OsStr;
-    use std::path::Path;
+    use std::{borrow::Cow, ffi::OsStr, path::Path};
 
     #[derive(Debug)]
     pub struct DirEntry<T: std::fmt::Debug> {
@@ -117,10 +115,7 @@ mod walkdir_precompose {
 ///
 #[cfg(feature = "fs-read-dir")]
 pub mod read_dir {
-    use std::borrow::Cow;
-    use std::ffi::OsStr;
-    use std::fs::FileType;
-    use std::path::Path;
+    use std::{borrow::Cow, ffi::OsStr, fs::FileType, path::Path};
 
     /// A directory entry adding precompose-unicode support to [`std::fs::DirEntry`].
     pub type DirEntry = super::walkdir_precompose::DirEntry<std::fs::DirEntry>;
@@ -143,10 +138,7 @@ pub mod read_dir {
 ///
 #[cfg(feature = "walkdir")]
 pub mod walkdir {
-    use std::borrow::Cow;
-    use std::ffi::OsStr;
-    use std::fs::FileType;
-    use std::path::Path;
+    use std::{borrow::Cow, ffi::OsStr, fs::FileType, path::Path};
 
     pub use walkdir::Error;
     use walkdir::{DirEntry as DirEntryImpl, WalkDir as WalkDirImpl};
diff --git a/gix-features/src/zlib/stream/deflate/tests.rs b/gix-features/src/zlib/stream/deflate/tests.rs
index 7c5865e0be6..84cdb30138b 100644
--- a/gix-features/src/zlib/stream/deflate/tests.rs
+++ b/gix-features/src/zlib/stream/deflate/tests.rs
@@ -45,6 +45,7 @@ mod deflate_stream {
         let r = InflateReader::from_read(io::BufReader::new(std::fs::File::open(fixture_path(
             "objects/37/d4e6c5c48ba0d245164c4e10d5f41140cab980",
         ))?));
+        #[allow(clippy::unbuffered_bytes)]
         let mut bytes = r.bytes();
         let content = bytes.by_ref().take(16).collect::<Result<Vec<_>, _>>()?;
         assert_eq!(content.as_slice().as_bstr(), b"blob 9\0hi there\n".as_bstr());
diff --git a/gix-filter/tests/driver/mod.rs b/gix-filter/tests/driver/mod.rs
index e4ba5cbbe9c..77cde3c851c 100644
--- a/gix-filter/tests/driver/mod.rs
+++ b/gix-filter/tests/driver/mod.rs
@@ -1,9 +1,10 @@
 static DRIVER: &str = concat!(env!("CARGO"), " run --example arrow");
 
 mod baseline {
-    use crate::driver::DRIVER;
     use serial_test::serial;
 
+    use crate::driver::DRIVER;
+
     #[serial]
     #[test]
     fn our_implementation_used_by_git() -> crate::Result {
diff --git a/gix-fs/src/dir/create.rs b/gix-fs/src/dir/create.rs
index bca6b982b5b..4238429f9e7 100644
--- a/gix-fs/src/dir/create.rs
+++ b/gix-fs/src/dir/create.rs
@@ -63,7 +63,8 @@ mod error {
                     retries,
                 } => write!(
                     f,
-                    "Permanently failing to create directory {dir:?} ({retries_left:?} of {retries:?})",
+                    "Permanently failing to create directory '{dir}' ({retries_left:?} of {retries:?})",
+                    dir = dir.display(),
                 ),
             }
         }
diff --git a/gix-fs/src/dir/remove.rs b/gix-fs/src/dir/remove.rs
index cb5bff47c88..03cad9fe686 100644
--- a/gix-fs/src/dir/remove.rs
+++ b/gix-fs/src/dir/remove.rs
@@ -20,7 +20,11 @@ impl<'a> Iter<'a> {
         if !target.starts_with(boundary) {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::InvalidInput,
-                format!("Removal target {target:?} must be contained in boundary {boundary:?}"),
+                format!(
+                    "Removal target '{target}' must be contained in boundary '{boundary}'",
+                    target = target.display(),
+                    boundary = boundary.display()
+                ),
             ));
         }
         let cursor = if target == boundary {
@@ -93,7 +97,7 @@ pub fn empty_depth_first(delete_dir: PathBuf) -> std::io::Result<()> {
             if entry.file_type()?.is_dir() {
                 next_to_push.push(entry.path());
             } else {
-                return Err(std::io::Error::new(std::io::ErrorKind::Other, "Directory not empty"));
+                return Err(std::io::Error::other("Directory not empty"));
             }
         }
         if num_entries == 0 {
diff --git a/gix-fs/src/snapshot.rs b/gix-fs/src/snapshot.rs
index 638096db843..41bdd3e51cb 100644
--- a/gix-fs/src/snapshot.rs
+++ b/gix-fs/src/snapshot.rs
@@ -1,7 +1,8 @@
 // TODO: tests
-use gix_features::threading::{get_mut, get_ref, MutableOnDemand, OwnShared};
 use std::ops::Deref;
 
+use gix_features::threading::{get_mut, get_ref, MutableOnDemand, OwnShared};
+
 /// A structure holding enough information to reload a value if its on-disk representation changes as determined by its modified time.
 #[derive(Debug)]
 pub struct FileSnapshot<T: std::fmt::Debug> {
diff --git a/gix-fs/src/stack.rs b/gix-fs/src/stack.rs
index 2486543d441..11aebe3f83b 100644
--- a/gix-fs/src/stack.rs
+++ b/gix-fs/src/stack.rs
@@ -1,7 +1,11 @@
-use crate::Stack;
+use std::{
+    ffi::OsStr,
+    path::{Component, Path, PathBuf},
+};
+
 use bstr::{BStr, BString, ByteSlice};
-use std::ffi::OsStr;
-use std::path::{Component, Path, PathBuf};
+
+use crate::Stack;
 
 ///
 pub mod to_normal_path_components {
@@ -156,10 +160,7 @@ impl Stack {
     ) -> std::io::Result<()> {
         let mut components = relative.to_normal_path_components().peekable();
         if self.valid_components != 0 && components.peek().is_none() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "empty inputs are not allowed",
-            ));
+            return Err(std::io::Error::other("empty inputs are not allowed"));
         }
         if self.valid_components == 0 {
             delegate.push_directory(self)?;
diff --git a/gix-fs/tests/fs/snapshot.rs b/gix-fs/tests/fs/snapshot.rs
index 00e0ad2d76e..406e1b76cb5 100644
--- a/gix-fs/tests/fs/snapshot.rs
+++ b/gix-fs/tests/fs/snapshot.rs
@@ -1,6 +1,7 @@
-use gix_fs::SharedFileSnapshotMut;
 use std::path::Path;
 
+use gix_fs::SharedFileSnapshotMut;
+
 #[test]
 fn journey() -> Result<(), Box<dyn std::error::Error>> {
     let tmp = tempfile::tempdir().unwrap();
diff --git a/gix-hash/src/hasher.rs b/gix-hash/src/hasher.rs
index 2a03c3d219a..4519f599e45 100644
--- a/gix-hash/src/hasher.rs
+++ b/gix-hash/src/hasher.rs
@@ -7,9 +7,10 @@ pub enum Error {
 }
 
 pub(super) mod _impl {
-    use crate::hasher::Error;
     use sha1_checked::{CollisionResult, Digest};
 
+    use crate::hasher::Error;
+
     /// An implementation of the Sha1 hash, which can be used once.
     ///
     /// We use [`sha1_checked`] to implement the same collision detection
diff --git a/gix-hash/src/io.rs b/gix-hash/src/io.rs
index f764d7c6b81..13abc42f23f 100644
--- a/gix-hash/src/io.rs
+++ b/gix-hash/src/io.rs
@@ -11,8 +11,7 @@ pub enum Error {
 }
 
 pub(super) mod _impl {
-    use crate::io::Error;
-    use crate::{hasher, Hasher};
+    use crate::{hasher, io::Error, Hasher};
 
     /// Compute the hash of `kind` for the bytes in the file at `path`, hashing only the first `num_bytes_from_start`
     /// while initializing and calling `progress`.
diff --git a/gix-index/src/access/mod.rs b/gix-index/src/access/mod.rs
index eaccb836db9..b4730c23e34 100644
--- a/gix-index/src/access/mod.rs
+++ b/gix-index/src/access/mod.rs
@@ -3,8 +3,11 @@ use std::{cmp::Ordering, ops::Range};
 use bstr::{BStr, ByteSlice, ByteVec};
 use filetime::FileTime;
 
-use crate::entry::{Stage, StageRaw};
-use crate::{entry, extension, AccelerateLookup, Entry, PathStorage, PathStorageRef, State, Version};
+use crate::{
+    entry,
+    entry::{Stage, StageRaw},
+    extension, AccelerateLookup, Entry, PathStorage, PathStorageRef, State, Version,
+};
 
 // TODO: integrate this somehow, somewhere, depending on later usage.
 #[allow(dead_code)]
diff --git a/gix-index/src/entry/mod.rs b/gix-index/src/entry/mod.rs
index 41f167bb902..595a791e217 100644
--- a/gix-index/src/entry/mod.rs
+++ b/gix-index/src/entry/mod.rs
@@ -107,10 +107,11 @@ mod access {
 mod _impls {
     use std::cmp::Ordering;
 
-    use crate::{entry, Entry, State};
     use bstr::BStr;
     use gix_object::tree::EntryKind;
 
+    use crate::{entry, Entry, State};
+
     impl From<EntryKind> for entry::Mode {
         fn from(value: EntryKind) -> Self {
             match value {
diff --git a/gix-index/src/extension/end_of_index_entry/decode.rs b/gix-index/src/extension/end_of_index_entry/decode.rs
index a9666bd64ce..e284a8a99d0 100644
--- a/gix-index/src/extension/end_of_index_entry/decode.rs
+++ b/gix-index/src/extension/end_of_index_entry/decode.rs
@@ -48,7 +48,7 @@ pub fn decode(data: &[u8], object_hash: gix_hash::Kind) -> Result<Option<usize>,
         return Ok(None);
     }
     // The last-to-this chunk ends where ours starts
-    if last_chunk.map_or(true, |s| s.as_ptr_range().end != (&data[start_of_eoie]) as *const _) {
+    if last_chunk.map_or(true, |s| !std::ptr::eq(s.as_ptr_range().end, &data[start_of_eoie])) {
         return Ok(None);
     }
 
diff --git a/gix-index/src/lib.rs b/gix-index/src/lib.rs
index a9d853f6960..ffc0afc4724 100644
--- a/gix-index/src/lib.rs
+++ b/gix-index/src/lib.rs
@@ -6,9 +6,9 @@
 #![cfg_attr(all(doc, feature = "document-features"), feature(doc_cfg, doc_auto_cfg))]
 #![deny(unsafe_code, missing_docs, rust_2018_idioms)]
 
-use bstr::{BStr, ByteSlice};
 use std::{ops::Range, path::PathBuf};
 
+use bstr::{BStr, ByteSlice};
 use filetime::FileTime;
 /// `gix_hash` is made available as it's part of the public API in various places.
 pub use gix_hash as hash;
@@ -157,10 +157,9 @@ pub struct State {
 }
 
 mod impls {
-    use crate::entry::Stage;
     use std::fmt::{Debug, Formatter};
 
-    use crate::State;
+    use crate::{entry::Stage, State};
 
     impl Debug for State {
         fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
diff --git a/gix-index/tests/index/access.rs b/gix-index/tests/index/access.rs
index 27ffd24ff69..78453d9f682 100644
--- a/gix-index/tests/index/access.rs
+++ b/gix-index/tests/index/access.rs
@@ -1,7 +1,8 @@
-use crate::index::Fixture;
 use bstr::{BString, ByteSlice};
 use gix_index::entry::Stage;
 
+use crate::index::Fixture;
+
 fn icase_fixture() -> gix_index::File {
     Fixture::Generated("v2_icase_name_clashes").open()
 }
diff --git a/gix-index/tests/index/init.rs b/gix-index/tests/index/init.rs
index 46da447393b..197a844e3ab 100644
--- a/gix-index/tests/index/init.rs
+++ b/gix-index/tests/index/init.rs
@@ -1,7 +1,7 @@
+use std::{error::Error, path::Path};
+
 use gix_index::State;
 use gix_testtools::scripted_fixture_read_only_standalone;
-use std::error::Error;
-use std::path::Path;
 
 #[test]
 fn from_tree() -> crate::Result {
diff --git a/gix-mailmap/src/lib.rs b/gix-mailmap/src/lib.rs
index 3f2c090b332..c32846c0c87 100644
--- a/gix-mailmap/src/lib.rs
+++ b/gix-mailmap/src/lib.rs
@@ -36,6 +36,13 @@ pub mod snapshot;
 /// optionally name to find mappings to new names and/or emails.
 ///
 /// The memory layout is efficient, even though lots of small allocations are performed to store strings of emails and names.
+///
+/// ### Handling of invalid `SignatureRef::time`
+///
+/// As the `time` field in [`SignatureRef`](gix_actor::SignatureRef) as passed by the caller maybe invalid,
+/// something that should be very rare but is possible, we decided to not expose this fallibility in the API.
+/// Hence, the user may separately check for the correctness of `time`, which we replace with [`gix_date::Time::default()`]
+/// in case of parse errors.
 #[derive(Default, Clone, Debug, Eq, PartialEq)]
 pub struct Snapshot {
     /// Sorted by `old_email`
diff --git a/gix-mailmap/src/snapshot/mod.rs b/gix-mailmap/src/snapshot/mod.rs
index 00abb58784c..59209477f39 100644
--- a/gix-mailmap/src/snapshot/mod.rs
+++ b/gix-mailmap/src/snapshot/mod.rs
@@ -138,7 +138,11 @@ impl Snapshot {
     ///
     /// Note that this method will always allocate.
     pub fn resolve(&self, signature: gix_actor::SignatureRef<'_>) -> gix_actor::Signature {
-        self.try_resolve(signature).unwrap_or_else(|| signature.to_owned())
+        self.try_resolve(signature).unwrap_or_else(|| gix_actor::Signature {
+            name: signature.name.to_owned(),
+            email: signature.email.to_owned(),
+            time: signature.time().unwrap_or_default(),
+        })
     }
 
     /// Like [`try_resolve()`][Snapshot::try_resolve()], but always returns a special copy-on-write signature, which contains
@@ -157,17 +161,17 @@ fn enriched_signature<'a>(
         (Some(new_email), Some(new_name)) => Signature {
             email: new_email.to_owned().into(),
             name: new_name.to_owned().into(),
-            time,
+            time: time.parse().unwrap_or_default(),
         },
         (Some(new_email), None) => Signature {
             email: new_email.to_owned().into(),
             name: name.into(),
-            time,
+            time: time.parse().unwrap_or_default(),
         },
         (None, Some(new_name)) => Signature {
             email: email.into(),
             name: new_name.to_owned().into(),
-            time,
+            time: time.parse().unwrap_or_default(),
         },
         (None, None) => unreachable!("BUG: ResolvedSignatures don't exist here when nothing is set"),
     }
diff --git a/gix-mailmap/src/snapshot/signature.rs b/gix-mailmap/src/snapshot/signature.rs
index 33f734257d7..4c3e0461218 100644
--- a/gix-mailmap/src/snapshot/signature.rs
+++ b/gix-mailmap/src/snapshot/signature.rs
@@ -29,7 +29,7 @@ impl<'a> From<gix_actor::SignatureRef<'a>> for Signature<'a> {
         Signature {
             name: s.name.into(),
             email: s.email.into(),
-            time: s.time,
+            time: s.time.parse().unwrap_or_default(),
         }
     }
 }
diff --git a/gix-mailmap/tests/snapshot/mod.rs b/gix-mailmap/tests/snapshot/mod.rs
index 82c24f609d5..db661ffc6f5 100644
--- a/gix-mailmap/tests/snapshot/mod.rs
+++ b/gix-mailmap/tests/snapshot/mod.rs
@@ -1,58 +1,60 @@
+use gix_date::parse::TimeBuf;
 use gix_mailmap::{Entry, Snapshot};
 use gix_testtools::fixture_bytes;
 
 #[test]
 fn try_resolve() {
     let snapshot = Snapshot::from_bytes(&fixture_bytes("typical.txt"));
+    let mut buf = TimeBuf::default();
     assert_eq!(
-        snapshot.try_resolve(signature("Foo", "Joe@example.com").to_ref()),
+        snapshot.try_resolve(signature("Foo", "Joe@example.com").to_ref(&mut buf)),
         Some(signature("Joe R. Developer", "joe@example.com")),
         "resolved signatures contain all original fields, and normalize the email as well to match the one that it was looked up with"
     );
     assert_eq!(
-        snapshot.try_resolve(signature("Joe", "bugs@example.com").to_ref()),
+        snapshot.try_resolve(signature("Joe", "bugs@example.com").to_ref(&mut buf)),
         Some(signature("Joe R. Developer", "joe@example.com")),
         "name and email can be mapped specifically"
     );
 
     assert_eq!(
-        snapshot.try_resolve(signature("Jane", "jane@laptop.(none)").to_ref()),
+        snapshot.try_resolve(signature("Jane", "jane@laptop.(none)").to_ref(&mut buf)),
         Some(signature("Jane Doe", "jane@example.com")),
         "fix name and email by email"
     );
     assert_eq!(
-        snapshot.try_resolve(signature("Jane", "jane@desktop.(none)").to_ref()),
+        snapshot.try_resolve(signature("Jane", "jane@desktop.(none)").to_ref(&mut buf)),
         Some(signature("Jane Doe", "jane@example.com")),
         "fix name and email by other email"
     );
 
     assert_eq!(
-        snapshot.try_resolve(signature("janE", "Bugs@example.com").to_ref()),
+        snapshot.try_resolve(signature("janE", "Bugs@example.com").to_ref(&mut buf)),
         Some(signature("Jane Doe", "jane@example.com")),
         "name and email can be mapped specifically, case insensitive matching of name"
     );
     assert_eq!(
-        snapshot.resolve(signature("janE", "jane@ipad.(none)").to_ref()),
+        snapshot.resolve(signature("janE", "jane@ipad.(none)").to_ref(&mut buf)),
         signature("janE", "jane@example.com"),
         "an email can be mapped by name and email specifically, both match case-insensitively"
     );
 
     let sig = signature("Jane", "other@example.com");
-    assert_eq!(snapshot.try_resolve(sig.to_ref()), None, "unmatched email");
+    assert_eq!(snapshot.try_resolve(sig.to_ref(&mut buf)), None, "unmatched email");
 
     assert_eq!(
-        snapshot.resolve(sig.to_ref()),
+        snapshot.resolve(sig.to_ref(&mut buf)),
         sig,
         "resolution always works here, returning a copy of the original"
     );
 
     let sig = signature("Jean", "bugs@example.com");
     assert_eq!(
-        snapshot.try_resolve(sig.to_ref()),
+        snapshot.try_resolve(sig.to_ref(&mut buf)),
         None,
         "matched email, unmatched name"
     );
-    assert_eq!(snapshot.resolve(sig.to_ref()), sig);
+    assert_eq!(snapshot.resolve(sig.to_ref(&mut buf)), sig);
 
     assert_eq!(
         snapshot.entries(),
@@ -85,16 +87,17 @@ fn non_name_and_name_mappings_will_not_clash() {
             "old-email",
         ),
     ];
+    let mut buf = TimeBuf::default();
     for entries in [entries.clone().into_iter().rev().collect::<Vec<_>>(), entries] {
         let snapshot = Snapshot::new(entries);
 
         assert_eq!(
-            snapshot.try_resolve(signature("replace-by-email", "Old-Email").to_ref()),
+            snapshot.try_resolve(signature("replace-by-email", "Old-Email").to_ref(&mut buf)),
             Some(signature("new-name", "old-email")),
             "it can match by email only, and the email is normalized"
         );
         assert_eq!(
-            snapshot.try_resolve(signature("old-name", "Old-Email").to_ref()),
+            snapshot.try_resolve(signature("old-name", "Old-Email").to_ref(&mut buf)),
             Some(signature("other-new-name", "other-new-email")),
             "it can match by email and name as well"
         );
@@ -117,26 +120,27 @@ fn non_name_and_name_mappings_will_not_clash() {
 #[test]
 fn overwrite_entries() {
     let snapshot = Snapshot::from_bytes(&fixture_bytes("overwrite.txt"));
+    let mut buf = TimeBuf::default();
     assert_eq!(
-        snapshot.try_resolve(signature("does not matter", "old-a-email").to_ref()),
+        snapshot.try_resolve(signature("does not matter", "old-a-email").to_ref(&mut buf)),
         Some(signature("A-overwritten", "old-a-email")),
         "email only by email"
     );
 
     assert_eq!(
-        snapshot.try_resolve(signature("to be replaced", "old-b-EMAIL").to_ref()),
+        snapshot.try_resolve(signature("to be replaced", "old-b-EMAIL").to_ref(&mut buf)),
         Some(signature("B-overwritten", "new-b-email-overwritten")),
         "name and email by email"
     );
 
     assert_eq!(
-        snapshot.try_resolve(signature("old-c", "old-C-email").to_ref()),
+        snapshot.try_resolve(signature("old-c", "old-C-email").to_ref(&mut buf)),
         Some(signature("C-overwritten", "new-c-email-overwritten")),
         "name and email by name and email"
     );
 
     assert_eq!(
-        snapshot.try_resolve(signature("unchanged", "old-d-email").to_ref()),
+        snapshot.try_resolve(signature("unchanged", "old-d-email").to_ref(&mut buf)),
         Some(signature("unchanged", "new-d-email-overwritten")),
         "email by email"
     );
@@ -161,11 +165,6 @@ fn signature(name: &str, email: &str) -> gix_actor::Signature {
     gix_actor::Signature {
         name: name.into(),
         email: email.into(),
-        time: gix_date::Time {
-            // marker
-            seconds: 42,
-            offset: 53,
-            sign: gix_date::time::Sign::Minus,
-        },
+        time: gix_date::parse_header("42 +0800").unwrap(),
     }
 }
diff --git a/gix-merge/src/blob/builtin_driver/binary.rs b/gix-merge/src/blob/builtin_driver/binary.rs
index 1314a91be80..e5886f132f6 100644
--- a/gix-merge/src/blob/builtin_driver/binary.rs
+++ b/gix-merge/src/blob/builtin_driver/binary.rs
@@ -21,8 +21,10 @@ pub enum Pick {
 }
 
 pub(super) mod function {
-    use crate::blob::builtin_driver::binary::{Pick, ResolveWith};
-    use crate::blob::Resolution;
+    use crate::blob::{
+        builtin_driver::binary::{Pick, ResolveWith},
+        Resolution,
+    };
 
     /// As this algorithm doesn't look at the actual data, it returns a choice solely based on logic.
     /// This also means that the caller has to assure this only gets called if the input *doesn't* match.
diff --git a/gix-merge/src/blob/builtin_driver/text/function.rs b/gix-merge/src/blob/builtin_driver/text/function.rs
index 2ff6ed3a3ad..d657e3797f5 100644
--- a/gix-merge/src/blob/builtin_driver/text/function.rs
+++ b/gix-merge/src/blob/builtin_driver/text/function.rs
@@ -1,12 +1,17 @@
-use crate::blob::builtin_driver::text::utils::{
-    assure_ends_with_nl, contains_lines, detect_line_ending, detect_line_ending_or_nl, fill_ancestor,
-    hunks_differ_in_diff3, take_intersecting, tokens, write_ancestor, write_conflict_marker, write_hunks,
-    zealously_contract_hunks, CollectHunks, Hunk, Side,
-};
-use crate::blob::builtin_driver::text::{Conflict, ConflictStyle, Labels, Options};
-use crate::blob::Resolution;
 use std::ops::Range;
 
+use crate::blob::{
+    builtin_driver::text::{
+        utils::{
+            assure_ends_with_nl, contains_lines, detect_line_ending, detect_line_ending_or_nl, fill_ancestor,
+            hunks_differ_in_diff3, take_intersecting, tokens, write_ancestor, write_conflict_marker, write_hunks,
+            zealously_contract_hunks, CollectHunks, Hunk, Side,
+        },
+        Conflict, ConflictStyle, Labels, Options,
+    },
+    Resolution,
+};
+
 /// Merge `current` and `other` with `ancestor` as base according to `opts`.
 ///
 /// Use `labels` to annotate conflict sections.
diff --git a/gix-merge/src/blob/builtin_driver/text/mod.rs b/gix-merge/src/blob/builtin_driver/text/mod.rs
index 198e0ba94d1..1b869b60402 100644
--- a/gix-merge/src/blob/builtin_driver/text/mod.rs
+++ b/gix-merge/src/blob/builtin_driver/text/mod.rs
@@ -1,6 +1,7 @@
-use bstr::BStr;
 use std::num::NonZeroU8;
 
+use bstr::BStr;
+
 /// The way the built-in [text driver](crate::blob::BuiltinDriver::Text) will express
 /// merge conflicts in the resulting file.
 #[derive(Default, Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
diff --git a/gix-merge/src/blob/builtin_driver/text/utils.rs b/gix-merge/src/blob/builtin_driver/text/utils.rs
index de880cf2e3c..54a6f23a35f 100644
--- a/gix-merge/src/blob/builtin_driver/text/utils.rs
+++ b/gix-merge/src/blob/builtin_driver/text/utils.rs
@@ -1,7 +1,8 @@
-use crate::blob::builtin_driver::text::ConflictStyle;
+use std::{iter::Peekable, ops::Range};
+
 use bstr::{BStr, ByteSlice, ByteVec};
-use std::iter::Peekable;
-use std::ops::Range;
+
+use crate::blob::builtin_driver::text::ConflictStyle;
 
 /// Used only when `diff3` is the conflict style as `zdiff3` automatically reduces hunks into nothing.
 /// Here we check if all hunks are the same.
diff --git a/gix-merge/src/blob/mod.rs b/gix-merge/src/blob/mod.rs
index 05a806bf6da..d480611cd26 100644
--- a/gix-merge/src/blob/mod.rs
+++ b/gix-merge/src/blob/mod.rs
@@ -1,10 +1,12 @@
 // TODO: remove this - only needed while &mut Vec<u8> isn't used.
 #![allow(clippy::ptr_arg)]
 
-use crate::blob::platform::{DriverChoice, ResourceRef};
-use bstr::BString;
 use std::path::PathBuf;
 
+use bstr::BString;
+
+use crate::blob::platform::{DriverChoice, ResourceRef};
+
 ///
 pub mod builtin_driver;
 ///
diff --git a/gix-merge/src/blob/pipeline.rs b/gix-merge/src/blob/pipeline.rs
index 82a6610748b..bdb58e7c930 100644
--- a/gix-merge/src/blob/pipeline.rs
+++ b/gix-merge/src/blob/pipeline.rs
@@ -1,10 +1,16 @@
-use super::{Pipeline, ResourceKind};
+use std::{
+    io::Read,
+    path::{Path, PathBuf},
+};
+
 use bstr::BStr;
-use gix_filter::driver::apply::{Delay, MaybeDelayed};
-use gix_filter::pipeline::convert::{ToGitOutcome, ToWorktreeOutcome};
+use gix_filter::{
+    driver::apply::{Delay, MaybeDelayed},
+    pipeline::convert::{ToGitOutcome, ToWorktreeOutcome},
+};
 use gix_object::tree::EntryKind;
-use std::io::Read;
-use std::path::{Path, PathBuf};
+
+use super::{Pipeline, ResourceKind};
 
 /// Options for use in a [`Pipeline`].
 #[derive(Default, Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd)]
diff --git a/gix-merge/src/blob/platform/merge.rs b/gix-merge/src/blob/platform/merge.rs
index 058a301287c..a19afb61957 100644
--- a/gix-merge/src/blob/platform/merge.rs
+++ b/gix-merge/src/blob/platform/merge.rs
@@ -1,6 +1,6 @@
+use std::{io::Read, path::PathBuf};
+
 use crate::blob::{builtin_driver, PlatformRef, Resolution};
-use std::io::Read;
-use std::path::PathBuf;
 
 /// Options for the use in the [`PlatformRef::merge()`] call.
 #[derive(Default, Copy, Clone, Debug, Eq, PartialEq)]
@@ -56,15 +56,22 @@ pub struct Command {
 pub(super) mod inner {
     ///
     pub mod prepare_external_driver {
-        use crate::blob::builtin_driver::text::Conflict;
-        use crate::blob::platform::{merge, DriverChoice};
-        use crate::blob::{builtin_driver, BuiltinDriver, Driver, PlatformRef, ResourceKind};
+        use std::{
+            io::Write,
+            ops::{Deref, DerefMut},
+            path::{Path, PathBuf},
+            process::Stdio,
+        };
+
         use bstr::{BString, ByteVec};
         use gix_tempfile::{AutoRemove, ContainingDirectory};
-        use std::io::Write;
-        use std::ops::{Deref, DerefMut};
-        use std::path::{Path, PathBuf};
-        use std::process::Stdio;
+
+        use crate::blob::{
+            builtin_driver,
+            builtin_driver::text::Conflict,
+            platform::{merge, DriverChoice},
+            BuiltinDriver, Driver, PlatformRef, ResourceKind,
+        };
 
         /// The error returned by [PlatformRef::prepare_external_driver()](PlatformRef::prepare_external_driver()).
         #[derive(Debug, thiserror::Error)]
@@ -267,9 +274,11 @@ pub(super) mod inner {
 
     ///
     pub mod builtin_merge {
-        use crate::blob::platform::resource;
-        use crate::blob::platform::resource::Data;
-        use crate::blob::{builtin_driver, BuiltinDriver, PlatformRef, Resolution};
+        use crate::blob::{
+            builtin_driver,
+            platform::{resource, resource::Data},
+            BuiltinDriver, PlatformRef, Resolution,
+        };
 
         /// An identifier to tell us how a merge conflict was resolved by [builtin_merge](PlatformRef::builtin_merge).
         #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
diff --git a/gix-merge/src/blob/platform/mod.rs b/gix-merge/src/blob/platform/mod.rs
index aa51102288e..662edc81dae 100644
--- a/gix-merge/src/blob/platform/mod.rs
+++ b/gix-merge/src/blob/platform/mod.rs
@@ -1,7 +1,8 @@
-use crate::blob::{pipeline, BuiltinDriver, Pipeline, Platform};
 use bstr::{BStr, BString};
 use gix_filter::attributes;
 
+use crate::blob::{pipeline, BuiltinDriver, Pipeline, Platform};
+
 /// A stored value representing a resource that participates in a merge.
 #[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Debug)]
 pub(super) struct Resource {
diff --git a/gix-merge/src/blob/platform/prepare_merge.rs b/gix-merge/src/blob/platform/prepare_merge.rs
index 310a5896637..417d4e4d60e 100644
--- a/gix-merge/src/blob/platform/prepare_merge.rs
+++ b/gix-merge/src/blob/platform/prepare_merge.rs
@@ -1,10 +1,13 @@
-use crate::blob::builtin_driver::text::Conflict;
-use crate::blob::platform::{merge, DriverChoice, ResourceRef};
-use crate::blob::{BuiltinDriver, Platform, PlatformRef, ResourceKind};
+use std::{num::NonZeroU8, str::FromStr};
+
 use bstr::{BStr, BString, ByteSlice};
 use gix_filter::attributes;
-use std::num::NonZeroU8;
-use std::str::FromStr;
+
+use crate::blob::{
+    builtin_driver::text::Conflict,
+    platform::{merge, DriverChoice, ResourceRef},
+    BuiltinDriver, Platform, PlatformRef, ResourceKind,
+};
 
 /// The error returned by [Platform::prepare_merge_state()](Platform::prepare_merge()).
 #[derive(Debug, thiserror::Error)]
diff --git a/gix-merge/src/blob/platform/set_resource.rs b/gix-merge/src/blob/platform/set_resource.rs
index 49f8248914b..c5a98d11252 100644
--- a/gix-merge/src/blob/platform/set_resource.rs
+++ b/gix-merge/src/blob/platform/set_resource.rs
@@ -1,7 +1,6 @@
 use bstr::{BStr, BString};
 
-use crate::blob::platform::Resource;
-use crate::blob::{pipeline, Platform, ResourceKind};
+use crate::blob::{pipeline, platform::Resource, Platform, ResourceKind};
 
 /// The error returned by [Platform::set_resource](Platform::set_resource).
 #[derive(Debug, thiserror::Error)]
diff --git a/gix-merge/src/commit/function.rs b/gix-merge/src/commit/function.rs
index 940369f8333..34f9d141977 100644
--- a/gix-merge/src/commit/function.rs
+++ b/gix-merge/src/commit/function.rs
@@ -1,8 +1,12 @@
-use crate::blob::builtin_driver;
-use crate::commit::{Error, Options};
-use gix_object::FindExt;
 use std::borrow::Cow;
 
+use gix_object::FindExt;
+
+use crate::{
+    blob::builtin_driver,
+    commit::{Error, Options},
+};
+
 /// Like [`tree()`](crate::tree()), but it takes only two commits, `our_commit` and `their_commit` to automatically
 /// compute the merge-bases among them.
 /// If there are multiple merge bases, these will be auto-merged into one, recursively, if
diff --git a/gix-merge/src/commit/virtual_merge_base.rs b/gix-merge/src/commit/virtual_merge_base.rs
index e67c5d2764d..d452a1c0fcd 100644
--- a/gix-merge/src/commit/virtual_merge_base.rs
+++ b/gix-merge/src/commit/virtual_merge_base.rs
@@ -28,11 +28,14 @@ pub enum Error {
 }
 
 pub(super) mod function {
-    use super::Error;
-    use crate::blob::builtin_driver;
-    use crate::tree::{treat_as_unresolved, TreatAsUnresolved};
     use gix_object::FindExt;
 
+    use super::Error;
+    use crate::{
+        blob::builtin_driver,
+        tree::{treat_as_unresolved, TreatAsUnresolved},
+    };
+
     /// Create a single virtual merge-base by merging `first_commit`, `second_commit` and `others` into one.
     /// Note that `first_commit` and `second_commit` are expected to have been popped off `others`, so `first_commit`
     /// was the last provided merge-base of function that provides multiple merge-bases for a pair of commits.
diff --git a/gix-merge/src/tree/function.rs b/gix-merge/src/tree/function.rs
index 029974c363a..9fadae7f4da 100644
--- a/gix-merge/src/tree/function.rs
+++ b/gix-merge/src/tree/function.rs
@@ -1,20 +1,24 @@
-use crate::tree::utils::{
-    apply_change, perform_blob_merge, possibly_rewritten_location, rewrite_location_with_renamed_directory,
-    to_components, track, unique_path_in_tree, ChangeList, ChangeListRef, PossibleConflict, TrackedChange, TreeNodes,
+use std::{borrow::Cow, convert::Infallible};
+
+use bstr::{BString, ByteSlice};
+use gix_diff::{tree::recorder::Location, tree_with_rewrites::Change};
+use gix_hash::ObjectId;
+use gix_object::{
+    tree,
+    tree::{EntryKind, EntryMode},
+    FindExt,
 };
-use crate::tree::ConflictMapping::{Original, Swapped};
+
 use crate::tree::{
-    Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping, ContentMerge, Error, Options, Outcome,
-    Resolution, ResolutionFailure, ResolveWith,
+    utils::{
+        apply_change, perform_blob_merge, possibly_rewritten_location, rewrite_location_with_renamed_directory,
+        to_components, track, unique_path_in_tree, ChangeList, ChangeListRef, PossibleConflict, TrackedChange,
+        TreeNodes,
+    },
+    Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping,
+    ConflictMapping::{Original, Swapped},
+    ContentMerge, Error, Options, Outcome, Resolution, ResolutionFailure, ResolveWith,
 };
-use bstr::{BString, ByteSlice};
-use gix_diff::tree::recorder::Location;
-use gix_diff::tree_with_rewrites::Change;
-use gix_hash::ObjectId;
-use gix_object::tree::{EntryKind, EntryMode};
-use gix_object::{tree, FindExt};
-use std::borrow::Cow;
-use std::convert::Infallible;
 
 /// Perform a merge between `our_tree` and `their_tree`, using `base_tree` as merge-base.
 /// Note that `base_tree` can be an empty tree to indicate 'no common ancestor between the two sides'.
diff --git a/gix-merge/src/tree/mod.rs b/gix-merge/src/tree/mod.rs
index cd82a2d2910..9288d197e71 100644
--- a/gix-merge/src/tree/mod.rs
+++ b/gix-merge/src/tree/mod.rs
@@ -1,6 +1,5 @@
 use bstr::BString;
-use gix_diff::tree_with_rewrites::Change;
-use gix_diff::Rewrites;
+use gix_diff::{tree_with_rewrites::Change, Rewrites};
 
 /// The error returned by [`tree()`](crate::tree()).
 #[derive(Debug, thiserror::Error)]
@@ -477,11 +476,15 @@ pub mod apply_index_entries {
     }
 
     pub(super) mod function {
-        use crate::tree::apply_index_entries::RemovalMode;
-        use crate::tree::{Conflict, ConflictIndexEntryPathHint, Resolution, ResolutionFailure, TreatAsUnresolved};
-        use bstr::{BStr, ByteSlice};
         use std::collections::{hash_map, HashMap};
 
+        use bstr::{BStr, ByteSlice};
+
+        use crate::tree::{
+            apply_index_entries::RemovalMode, Conflict, ConflictIndexEntryPathHint, Resolution, ResolutionFailure,
+            TreatAsUnresolved,
+        };
+
         /// Returns `true` if `index` changed as we applied conflicting stages to it, using `how` to determine if a
         /// conflict should be considered unresolved.
         /// Once a stage of a path conflicts, the unconflicting stage is removed even though it might be the one
diff --git a/gix-merge/src/tree/utils.rs b/gix-merge/src/tree/utils.rs
index 49c8efe20b2..9b21c9b69d4 100644
--- a/gix-merge/src/tree/utils.rs
+++ b/gix-merge/src/tree/utils.rs
@@ -5,19 +5,23 @@
 //!
 //! Once such a case becomes a bug and is reproduced in testing, the debug-assertion will kick in and hopefully
 //! contribute to finding a fix faster.
-use crate::blob::builtin_driver::binary::Pick;
-use crate::blob::ResourceKind;
-use crate::tree::{
-    Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping, Error, Options, Resolution,
-    ResolutionFailure,
-};
-use bstr::ByteSlice;
-use bstr::{BStr, BString, ByteVec};
+use std::collections::HashMap;
+
+use bstr::{BStr, BString, ByteSlice, ByteVec};
 use gix_diff::tree_with_rewrites::{Change, ChangeRef};
 use gix_hash::ObjectId;
-use gix_object::tree;
-use gix_object::tree::{EntryKind, EntryMode};
-use std::collections::HashMap;
+use gix_object::{
+    tree,
+    tree::{EntryKind, EntryMode},
+};
+
+use crate::{
+    blob::{builtin_driver::binary::Pick, ResourceKind},
+    tree::{
+        Conflict, ConflictIndexEntry, ConflictIndexEntryPathHint, ConflictMapping, Error, Options, Resolution,
+        ResolutionFailure,
+    },
+};
 
 /// Assuming that `their_location` is the destination of *their* rewrite, check if *it* passes
 /// over a directory rewrite in *our* tree. If so, rewrite it so that we get the path
diff --git a/gix-merge/tests/merge/blob/builtin_driver.rs b/gix-merge/tests/merge/blob/builtin_driver.rs
index 0ddb94da67d..f7593f22b82 100644
--- a/gix-merge/tests/merge/blob/builtin_driver.rs
+++ b/gix-merge/tests/merge/blob/builtin_driver.rs
@@ -1,5 +1,8 @@
-use gix_merge::blob::builtin_driver::binary::{Pick, ResolveWith};
-use gix_merge::blob::{builtin_driver, Resolution};
+use gix_merge::blob::{
+    builtin_driver,
+    builtin_driver::binary::{Pick, ResolveWith},
+    Resolution,
+};
 
 #[test]
 fn binary() {
@@ -25,8 +28,11 @@ fn binary() {
 
 mod text {
     use bstr::ByteSlice;
-    use gix_merge::blob::builtin_driver::text::{Conflict, ConflictStyle};
-    use gix_merge::blob::{builtin_driver, Resolution};
+    use gix_merge::blob::{
+        builtin_driver,
+        builtin_driver::text::{Conflict, ConflictStyle},
+        Resolution,
+    };
     use pretty_assertions::assert_str_eq;
 
     const DIVERGING: &[&str] = &[
@@ -292,9 +298,10 @@ mod text {
     }
 
     mod baseline {
+        use std::path::Path;
+
         use bstr::BString;
         use gix_merge::blob::builtin_driver::text::{Conflict, ConflictStyle};
-        use std::path::Path;
 
         #[derive(Debug)]
         pub struct Expectation {
diff --git a/gix-merge/tests/merge/blob/pipeline.rs b/gix-merge/tests/merge/blob/pipeline.rs
index 86c856808db..e01b980a776 100644
--- a/gix-merge/tests/merge/blob/pipeline.rs
+++ b/gix-merge/tests/merge/blob/pipeline.rs
@@ -1,11 +1,13 @@
-use crate::blob::util::ObjectDb;
 use bstr::ByteSlice;
-use gix_filter::eol;
-use gix_filter::eol::AutoCrlf;
-use gix_merge::blob::pipeline::{self, Mode, WorktreeRoots};
-use gix_merge::blob::{Pipeline, ResourceKind};
+use gix_filter::{eol, eol::AutoCrlf};
+use gix_merge::blob::{
+    pipeline::{self, Mode, WorktreeRoots},
+    Pipeline, ResourceKind,
+};
 use gix_object::tree::EntryKind;
 
+use crate::blob::util::ObjectDb;
+
 const ALL_MODES: [pipeline::Mode; 2] = [pipeline::Mode::ToGit, pipeline::Mode::Renormalize];
 
 #[test]
diff --git a/gix-merge/tests/merge/blob/platform.rs b/gix-merge/tests/merge/blob/platform.rs
index 7bb38ed305e..0af089920c3 100644
--- a/gix-merge/tests/merge/blob/platform.rs
+++ b/gix-merge/tests/merge/blob/platform.rs
@@ -1,19 +1,23 @@
-use gix_worktree::stack::state::attributes;
-
 use gix_merge::blob::Platform;
+use gix_worktree::stack::state::attributes;
 
 mod merge {
-    use crate::blob::platform::new_platform;
-    use crate::blob::util::ObjectDb;
-    use crate::hex_to_id;
+    use std::{convert::Infallible, process::Stdio};
+
     use bstr::{BStr, ByteSlice};
-    use gix_merge::blob::builtin_driver::text::ConflictStyle;
-    use gix_merge::blob::platform::builtin_merge::Pick;
-    use gix_merge::blob::platform::DriverChoice;
-    use gix_merge::blob::{builtin_driver, pipeline, platform, BuiltinDriver, Resolution, ResourceKind};
+    use gix_merge::blob::{
+        builtin_driver,
+        builtin_driver::text::ConflictStyle,
+        pipeline, platform,
+        platform::{builtin_merge::Pick, DriverChoice},
+        BuiltinDriver, Resolution, ResourceKind,
+    };
     use gix_object::tree::EntryKind;
-    use std::convert::Infallible;
-    use std::process::Stdio;
+
+    use crate::{
+        blob::{platform::new_platform, util::ObjectDb},
+        hex_to_id,
+    };
 
     #[test]
     fn builtin_text_uses_binary_if_needed() -> crate::Result {
@@ -495,11 +499,15 @@ theirs
 }
 
 mod prepare_merge {
-    use crate::blob::platform::new_platform;
-    use gix_merge::blob::platform::{resource, DriverChoice};
-    use gix_merge::blob::{builtin_driver, pipeline, BuiltinDriver, ResourceKind};
+    use gix_merge::blob::{
+        builtin_driver, pipeline,
+        platform::{resource, DriverChoice},
+        BuiltinDriver, ResourceKind,
+    };
     use gix_object::tree::EntryKind;
 
+    use crate::blob::platform::new_platform;
+
     #[test]
     fn ancestor_and_current_and_other_do_not_exist() -> crate::Result {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
@@ -705,10 +713,11 @@ mod prepare_merge {
 }
 
 mod set_resource {
-    use crate::blob::platform::new_platform;
     use gix_merge::blob::{pipeline, ResourceKind};
     use gix_object::tree::EntryKind;
 
+    use crate::blob::platform::new_platform;
+
     #[test]
     fn invalid_resource_types() {
         let mut platform = new_platform(None, pipeline::Mode::ToGit);
diff --git a/gix-merge/tests/merge/tree/baseline.rs b/gix-merge/tests/merge/tree/baseline.rs
index 32df03ffcb3..7401c052e7c 100644
--- a/gix-merge/tests/merge/tree/baseline.rs
+++ b/gix-merge/tests/merge/tree/baseline.rs
@@ -1,9 +1,9 @@
+use std::path::{Path, PathBuf};
+
 use bstr::{BStr, ByteSlice};
 use gix_hash::ObjectId;
 use gix_merge::blob::builtin_driver::text::ConflictStyle;
-use gix_object::tree::EntryMode;
-use gix_object::FindExt;
-use std::path::{Path, PathBuf};
+use gix_object::{tree::EntryMode, FindExt};
 
 /// An entry in the conflict
 #[derive(Debug, Eq, PartialEq)]
diff --git a/gix-merge/tests/merge/tree/mod.rs b/gix-merge/tests/merge/tree/mod.rs
index dfe0971ed3c..5c66142b48f 100644
--- a/gix-merge/tests/merge/tree/mod.rs
+++ b/gix-merge/tests/merge/tree/mod.rs
@@ -1,11 +1,14 @@
-use crate::tree::baseline::Deviation;
+use std::path::Path;
+
 use gix_diff::Rewrites;
-use gix_merge::commit::Options;
-use gix_merge::tree::apply_index_entries::RemovalMode;
-use gix_merge::tree::{treat_as_unresolved, TreatAsUnresolved};
+use gix_merge::{
+    commit::Options,
+    tree::{apply_index_entries::RemovalMode, treat_as_unresolved, TreatAsUnresolved},
+};
 use gix_object::Write;
 use gix_worktree::stack::state::attributes;
-use std::path::Path;
+
+use crate::tree::baseline::Deviation;
 
 /// ### How to add a new baseline test
 ///
diff --git a/gix-object/benches/edit_tree.rs b/gix-object/benches/edit_tree.rs
index 8154a7c1c76..f54caf7cd18 100644
--- a/gix-object/benches/edit_tree.rs
+++ b/gix-object/benches/edit_tree.rs
@@ -1,10 +1,9 @@
+use std::{cell::RefCell, rc::Rc};
+
 use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
 use gix_hash::ObjectId;
 use gix_hashtable::hash_map::Entry;
-use gix_object::tree::EntryKind;
-use gix_object::{tree, Tree, WriteTo};
-use std::cell::RefCell;
-use std::rc::Rc;
+use gix_object::{tree, tree::EntryKind, Tree, WriteTo};
 
 fn create_new_tree_add_and_remove(c: &mut Criterion) {
     let (storage, mut write) = new_inmemory_writes();
diff --git a/gix-object/src/commit/mod.rs b/gix-object/src/commit/mod.rs
index 8cc49647158..aeac4454733 100644
--- a/gix-object/src/commit/mod.rs
+++ b/gix-object/src/commit/mod.rs
@@ -110,9 +110,9 @@ impl<'a> CommitRef<'a> {
         MessageRef::from_bytes(self.message)
     }
 
-    /// Returns the time at which this commit was created.
+    /// Returns the time at which this commit was created, or a default time if it could not be parsed.
     pub fn time(&self) -> gix_date::Time {
-        self.committer.time
+        self.committer.time.parse().unwrap_or_default()
     }
 }
 
diff --git a/gix-object/src/commit/write.rs b/gix-object/src/commit/write.rs
index 8f7041370d6..fc9cf025b18 100644
--- a/gix-object/src/commit/write.rs
+++ b/gix-object/src/commit/write.rs
@@ -11,8 +11,9 @@ impl crate::WriteTo for Commit {
         for parent in &self.parents {
             encode::trusted_header_id(b"parent", parent, &mut out)?;
         }
-        encode::trusted_header_signature(b"author", &self.author.to_ref(), &mut out)?;
-        encode::trusted_header_signature(b"committer", &self.committer.to_ref(), &mut out)?;
+        let mut buf = gix_date::parse::TimeBuf::default();
+        encode::trusted_header_signature(b"author", &self.author.to_ref(&mut buf), &mut out)?;
+        encode::trusted_header_signature(b"committer", &self.committer.to_ref(&mut buf), &mut out)?;
         if let Some(encoding) = self.encoding.as_ref() {
             encode::header_field(b"encoding", encoding, &mut out)?;
         }
diff --git a/gix-object/src/tag/write.rs b/gix-object/src/tag/write.rs
index 520084f4af5..7bde5a89688 100644
--- a/gix-object/src/tag/write.rs
+++ b/gix-object/src/tag/write.rs
@@ -1,6 +1,7 @@
 use std::io;
 
 use bstr::BStr;
+use gix_date::parse::TimeBuf;
 
 use crate::{encode, encode::NL, Kind, Tag, TagRef};
 
@@ -26,7 +27,8 @@ impl crate::WriteTo for Tag {
         encode::trusted_header_field(b"type", self.target_kind.as_bytes(), out)?;
         encode::header_field(b"tag", validated_name(self.name.as_ref())?, out)?;
         if let Some(tagger) = &self.tagger {
-            encode::trusted_header_signature(b"tagger", &tagger.to_ref(), out)?;
+            let mut buf = TimeBuf::default();
+            encode::trusted_header_signature(b"tagger", &tagger.to_ref(&mut buf), out)?;
         }
 
         if !self.message.iter().all(|b| *b == b'\n') {
diff --git a/gix-object/src/traits/_impls.rs b/gix-object/src/traits/_impls.rs
index 5a1347a3430..385e62363ea 100644
--- a/gix-object/src/traits/_impls.rs
+++ b/gix-object/src/traits/_impls.rs
@@ -1,9 +1,8 @@
-use crate::{Kind, WriteTo};
+use std::{io::Read, ops::Deref, rc::Rc, sync::Arc};
+
 use gix_hash::ObjectId;
-use std::io::Read;
-use std::ops::Deref;
-use std::rc::Rc;
-use std::sync::Arc;
+
+use crate::{Kind, WriteTo};
 
 impl<T> crate::Write for &T
 where
diff --git a/gix-object/src/tree/editor.rs b/gix-object/src/tree/editor.rs
index 3e4e9fa7a19..5dc6dd580fd 100644
--- a/gix-object/src/tree/editor.rs
+++ b/gix-object/src/tree/editor.rs
@@ -1,10 +1,17 @@
-use crate::tree::{Editor, EntryKind};
-use crate::{tree, Tree};
+use std::{
+    cmp::Ordering,
+    collections::{hash_map, HashMap},
+    fmt::Formatter,
+};
+
 use bstr::{BStr, BString, ByteSlice, ByteVec};
 use gix_hash::ObjectId;
-use std::cmp::Ordering;
-use std::collections::{hash_map, HashMap};
-use std::fmt::Formatter;
+
+use crate::{
+    tree,
+    tree::{Editor, EntryKind},
+    Tree,
+};
 
 /// A way to constrain all [tree-edits](Editor) to a given subtree.
 pub struct Cursor<'a, 'find> {
@@ -368,12 +375,18 @@ impl Editor<'_> {
 }
 
 mod cursor {
-    use crate::tree::editor::{Cursor, UpsertMode, WriteMode};
-    use crate::tree::{Editor, EntryKind};
-    use crate::{tree, Tree};
     use bstr::{BStr, BString};
     use gix_hash::ObjectId;
 
+    use crate::{
+        tree,
+        tree::{
+            editor::{Cursor, UpsertMode, WriteMode},
+            Editor, EntryKind,
+        },
+        Tree,
+    };
+
     /// Cursor handling
     impl<'a> Editor<'a> {
         /// Turn ourselves as a cursor, which points to the same tree as the editor.
diff --git a/gix-object/src/tree/mod.rs b/gix-object/src/tree/mod.rs
index b7ae614965b..3bde58146cf 100644
--- a/gix-object/src/tree/mod.rs
+++ b/gix-object/src/tree/mod.rs
@@ -1,9 +1,9 @@
+use std::{cell::RefCell, cmp::Ordering};
+
 use crate::{
     bstr::{BStr, BString},
     tree, Tree, TreeRef,
 };
-use std::cell::RefCell;
-use std::cmp::Ordering;
 
 ///
 pub mod editor;
diff --git a/gix-object/src/tree/ref_iter.rs b/gix-object/src/tree/ref_iter.rs
index 72f3233defc..7e60d6ac831 100644
--- a/gix-object/src/tree/ref_iter.rs
+++ b/gix-object/src/tree/ref_iter.rs
@@ -1,7 +1,8 @@
-use crate::{tree, tree::EntryRef, TreeRef, TreeRefIter};
 use bstr::BStr;
 use winnow::{error::ParserError, prelude::*};
 
+use crate::{tree, tree::EntryRef, TreeRef, TreeRefIter};
+
 impl<'a> TreeRefIter<'a> {
     /// Instantiate an iterator from the given tree data.
     pub fn from_bytes(data: &'a [u8]) -> TreeRefIter<'a> {
diff --git a/gix-object/tests/object/commit/from_bytes.rs b/gix-object/tests/object/commit/from_bytes.rs
index 9a7e0f23842..7f9fea67abd 100644
--- a/gix-object/tests/object/commit/from_bytes.rs
+++ b/gix-object/tests/object/commit/from_bytes.rs
@@ -1,22 +1,18 @@
+use gix_actor::SignatureRef;
+use gix_object::{bstr::ByteSlice, commit::message::body::TrailerRef, CommitRef};
+use smallvec::SmallVec;
+
 use crate::{
     commit::{LONG_MESSAGE, MERGE_TAG, SIGNATURE},
     fixture_name, linus_signature, signature,
 };
-use gix_actor::SignatureRef;
-use gix_date::{time::Sign, Time};
-use gix_object::{bstr::ByteSlice, commit::message::body::TrailerRef, CommitRef};
-use smallvec::SmallVec;
 
 #[test]
 fn invalid_timestsamp() {
     let actor = gix_actor::SignatureRef {
         name: b"Name".as_bstr(),
         email: b"name@example.com".as_bstr(),
-        time: Time {
-            seconds: 1312735823,
-            offset: 0,
-            sign: Sign::Plus,
-        },
+        time: "1312735823 +051800",
     };
     assert_eq!(
         CommitRef::from_bytes(&fixture_name("commit", "invalid-timestamp.txt"))
@@ -39,11 +35,7 @@ fn invalid_email_of_committer() {
     let actor = gix_actor::SignatureRef {
         name: b"Gregor Hartmann".as_bstr(),
         email: b"gh <Gregor Hartmann<gh@openoffice.org".as_bstr(),
-        time: Time {
-            seconds: 1282910542,
-            offset: 2 * 60 * 60,
-            sign: Sign::Plus,
-        },
+        time: "1282910542 +0200",
     };
     assert_eq!(
         CommitRef::from_bytes(&fixture_name("commit", "invalid-actor.txt"))
@@ -67,8 +59,8 @@ fn unsigned() -> crate::Result {
         CommitRef {
             tree: b"1b2dfb4ac5e42080b682fc676e9738c94ce6d54d".as_bstr(),
             parents: SmallVec::default(),
-            author: signature(1592437401),
-            committer: signature(1592437401),
+            author: signature("1592437401 +0800"),
+            committer: signature("1592437401 +0800"),
             encoding: None,
             message: b"without sig".as_bstr(),
             extra_headers: vec![]
@@ -84,8 +76,8 @@ fn whitespace() -> crate::Result {
         CommitRef {
             tree: b"9bed6275068a0575243ba8409253e61af81ab2ff".as_bstr(),
             parents: SmallVec::from(vec![b"26b4df046d1776c123ac69d918f5aec247b58cc6".as_bstr()]),
-            author: signature(1592448450),
-            committer: signature(1592448450),
+            author: signature("1592448450 +0800"),
+            committer: signature("1592448450 +0800"),
             encoding: None,
             message: b" nl".as_bstr(), // this one had a \n trailing it, but git seems to trim that
             extra_headers: vec![]
@@ -101,8 +93,8 @@ fn signed_singleline() -> crate::Result {
         CommitRef {
             tree: b"00fc39317701176e326974ce44f5bd545a32ec0b".as_bstr(),
             parents: SmallVec::from(vec![b"09d8d3a12e161a7f6afb522dbe8900a9c09bce06".as_bstr()]),
-            author: signature(1592391367),
-            committer: signature(1592391367),
+            author: signature("1592391367 +0800"),
+            committer: signature("1592391367 +0800"),
             encoding: None,
             message: b"update tasks\n".as_bstr(),
             extra_headers: vec![(b"gpgsig".as_bstr(), b"magic:signature".as_bstr().into())]
@@ -120,8 +112,8 @@ fn mergetag() -> crate::Result {
             b"44ebe016df3aad96e3be8f95ec52397728dd7701".as_bstr(),
             b"8d485da0ddee79d0e6713405694253d401e41b93".as_bstr(),
         ]),
-        author: linus_signature(1591996221),
-        committer: linus_signature(1591996221),
+        author: linus_signature("1591996221 -0700"),
+        committer: linus_signature("1591996221 -0700"),
         encoding: None,
         message: LONG_MESSAGE.as_bytes().as_bstr(),
         extra_headers: vec![(
@@ -142,8 +134,8 @@ fn signed() -> crate::Result {
         CommitRef {
             tree: b"00fc39317701176e326974ce44f5bd545a32ec0b".as_bstr(),
             parents: SmallVec::from(vec![b"09d8d3a12e161a7f6afb522dbe8900a9c09bce06".as_bstr()]),
-            author: signature(1592391367),
-            committer: signature(1592391367),
+            author: signature("1592391367 +0800"),
+            committer: signature("1592391367 +0800"),
             encoding: None,
             message: b"update tasks\n".as_bstr(),
             extra_headers: vec![(b"gpgsig".as_bstr(), b"-----BEGIN PGP SIGNATURE-----\n\niQEzBAABCAAdFiEEdjYp/sh4j8NRKLX27gKdHl60AwAFAl7p9tgACgkQ7gKdHl60\nAwBpegf+KQciv9AOIN7+yPmowecGxBnSfpKWTDzFxnyGR8dq63SpWT8WEKG5mf3a\nG6iUqpsDWaMHlzihaMKRvgRpZxFRbjnNPFBj6F4RRqfE+5R7k6DRSLUV5PqnsdSH\nuccfIDWi1imhsm7AaP5trwl1t+83U2JhHqPcPVFLMODYwWeO6NLR/JCzGSTQRa8t\nRgaVMKI19O/fge5OT5Ua8D47VKEhsJX0LfmkP5RfZQ8JJvNd40TupqKRdlv0sAzP\nya7NXkSHXCavHNR6kA+KpWxn900UoGK8/IDlwU6MeOkpPVawb3NFMqnc7KJDaC2p\nSMzpuEG8LTrCx2YSpHNLqHyzvQ1CZA==\n=5ITV\n-----END PGP SIGNATURE-----\n".as_bstr().into())]
@@ -159,8 +151,8 @@ fn signed_with_encoding() -> crate::Result {
         CommitRef {
             tree: b"1973afa74d87b2bb73fa884aaaa8752aec43ea88".as_bstr(),
             parents: SmallVec::from(vec![b"79c51cc86923e2b8ca0ee5c4eb75e48027133f9a".as_bstr()]),
-            author: signature(1592448995),
-            committer: signature(1592449083),
+            author: signature("1592448995 +0800"),
+            committer: signature("1592449083 +0800"),
             encoding: Some(b"ISO-8859-1".as_bstr()),
             message: b"encoding & sig".as_bstr(),
             extra_headers: vec![(b"gpgsig".as_bstr(), SIGNATURE.as_bstr().into())]
@@ -176,8 +168,8 @@ fn with_encoding() -> crate::Result {
         CommitRef {
             tree: b"4a1c03029e7407c0afe9fc0320b3258e188b115e".as_bstr(),
             parents: SmallVec::from(vec![b"7ca98aad461a5c302cb4c9e3acaaa6053cc67a62".as_bstr()]),
-            author: signature(1592438199),
-            committer: signature(1592438199),
+            author: signature("1592438199 +0800"),
+            committer: signature("1592438199 +0800"),
             encoding: Some("ISO-8859-1".into()),
             message: b"commit with encoding".as_bstr(),
             extra_headers: vec![]
@@ -191,11 +183,7 @@ fn pre_epoch() -> crate::Result {
     let signature = || SignatureRef {
         name: "Législateur".into(),
         email: "".into(),
-        time: Time {
-            seconds: -5263834140,
-            offset: 540,
-            sign: Sign::Plus,
-        },
+        time: "-5263834140 +0009",
     };
     assert_eq!(
         CommitRef::from_bytes(&fixture_name("commit", "pre-epoch.txt"))?,
@@ -217,11 +205,7 @@ fn double_dash_special_time_offset() -> crate::Result {
     let signature = || SignatureRef {
         name: "name".into(),
         email: "name@example.com".into(),
-        time: Time {
-            seconds: 1288373970,
-            offset: -252000,
-            sign: Sign::Minus,
-        },
+        time: "1288373970 --700",
     };
     assert_eq!(
         CommitRef::from_bytes(&fixture_name("commit", "double-dash-date-offset.txt"))?,
@@ -243,11 +227,7 @@ fn with_trailer() -> crate::Result {
     let kim = SignatureRef {
         name: "Kim Altintop".into(),
         email: "kim@eagain.st".into(),
-        time: Time {
-            seconds: 1631514803,
-            offset: 7200,
-            sign: Sign::Plus,
-        },
+        time: "1631514803 +0200",
     };
     let backing = fixture_name("commit", "message-with-footer.txt");
     let commit = CommitRef::from_bytes(&backing)?;
@@ -336,8 +316,8 @@ fn merge() -> crate::Result {
                 b"6a6054db4ce3c1e4e6a37f8c4d7acb63a4d6ad71".as_bstr(),
                 b"c91d592913d47ac4e4a76daf16fd649b276e211e".as_bstr()
             ]),
-            author: signature(1592454703),
-            committer: signature(1592454738),
+            author: signature("1592454703 +0800"),
+            committer: signature("1592454738 +0800"),
             encoding: Some("ISO-8859-1".into()),
             message: b"Merge branch 'branch'".as_bstr(),
             extra_headers: vec![]
diff --git a/gix-object/tests/object/commit/iter.rs b/gix-object/tests/object/commit/iter.rs
index f1562dfb9f5..6991ba14472 100644
--- a/gix-object/tests/object/commit/iter.rs
+++ b/gix-object/tests/object/commit/iter.rs
@@ -33,10 +33,10 @@ fn signed_with_encoding() -> crate::Result {
                 id: hex_to_id("79c51cc86923e2b8ca0ee5c4eb75e48027133f9a")
             },
             Token::Author {
-                signature: signature(1592448995)
+                signature: signature("1592448995 +0800")
             },
             Token::Committer {
-                signature: signature(1592449083)
+                signature: signature("1592449083 +0800")
             },
             Token::Encoding(b"ISO-8859-1".as_bstr()),
             Token::ExtraHeader((b"gpgsig".as_bstr(), SIGNATURE.as_bytes().as_bstr().into())),
@@ -44,8 +44,8 @@ fn signed_with_encoding() -> crate::Result {
         ]
     );
 
-    assert_eq!(iter.author().ok(), Some(signature(1592448995)));
-    assert_eq!(iter.committer().ok(), Some(signature(1592449083)));
+    assert_eq!(iter.author().ok(), Some(signature("1592448995 +0800")));
+    assert_eq!(iter.committer().ok(), Some(signature("1592449083 +0800")));
     Ok(())
 }
 
@@ -61,10 +61,10 @@ fn whitespace() -> crate::Result {
                 id: hex_to_id("26b4df046d1776c123ac69d918f5aec247b58cc6")
             },
             Token::Author {
-                signature: signature(1592448450)
+                signature: signature("1592448450 +0800")
             },
             Token::Committer {
-                signature: signature(1592448450)
+                signature: signature("1592448450 +0800")
             },
             Token::Message(b" nl".as_bstr())
         ]
@@ -81,10 +81,10 @@ fn unsigned() -> crate::Result {
                 id: hex_to_id("1b2dfb4ac5e42080b682fc676e9738c94ce6d54d")
             },
             Token::Author {
-                signature: signature(1592437401)
+                signature: signature("1592437401 +0800")
             },
             Token::Committer {
-                signature: signature(1592437401)
+                signature: signature("1592437401 +0800")
             },
             Token::Message(b"without sig".as_bstr())
         ]
@@ -104,10 +104,10 @@ fn signed_singleline() -> crate::Result {
                 id: hex_to_id("09d8d3a12e161a7f6afb522dbe8900a9c09bce06")
             },
             Token::Author {
-                signature: signature(1592391367)
+                signature: signature("1592391367 +0800")
             },
             Token::Committer {
-                signature: signature(1592391367)
+                signature: signature("1592391367 +0800")
             },
             Token::ExtraHeader((b"gpgsig".as_bstr(), b"magic:signature".as_bstr().into())),
             Token::Message(b"update tasks\n".as_bstr()),
@@ -151,10 +151,10 @@ fn mergetag() -> crate::Result {
                 id: hex_to_id("8d485da0ddee79d0e6713405694253d401e41b93")
             },
             Token::Author {
-                signature: linus_signature(1591996221)
+                signature: linus_signature("1591996221 -0700")
             },
             Token::Committer {
-                signature: linus_signature(1591996221)
+                signature: linus_signature("1591996221 -0700")
             },
             Token::ExtraHeader((b"mergetag".as_bstr(), MERGE_TAG.as_bytes().as_bstr().into())),
             Token::Message(LONG_MESSAGE.into()),
@@ -186,7 +186,7 @@ mod method {
         );
         assert_eq!(
             iter.signatures().collect::<Vec<_>>(),
-            vec![signature(1592437401), signature(1592437401)]
+            vec![signature("1592437401 +0800"), signature("1592437401 +0800")]
         );
         assert_eq!(iter.parent_ids().count(), 0);
         Ok(())
@@ -198,11 +198,15 @@ mod method {
         let iter = CommitRefIter::from_bytes(&input);
         assert_eq!(
             iter.signatures().collect::<Vec<_>>(),
-            vec![signature(1592437401), signature(1592437401)]
+            vec![signature("1592437401 +0800"), signature("1592437401 +0800")]
+        );
+        assert_eq!(iter.author().ok(), Some(signature("1592437401 +0800")));
+        assert_eq!(iter.committer().ok(), Some(signature("1592437401 +0800")));
+        assert_eq!(
+            iter.author().ok(),
+            Some(signature("1592437401 +0800")),
+            "it's not consuming"
         );
-        assert_eq!(iter.author().ok(), Some(signature(1592437401)));
-        assert_eq!(iter.committer().ok(), Some(signature(1592437401)));
-        assert_eq!(iter.author().ok(), Some(signature(1592437401)), "it's not consuming");
         Ok(())
     }
 
diff --git a/gix-object/tests/object/commit/message.rs b/gix-object/tests/object/commit/message.rs
index 35cf97de72b..732c1b929a6 100644
--- a/gix-object/tests/object/commit/message.rs
+++ b/gix-object/tests/object/commit/message.rs
@@ -224,7 +224,6 @@ mod summary {
     use std::borrow::Cow;
 
     use gix_actor::SignatureRef;
-    use gix_date::{time::Sign, Time};
     use gix_object::{
         bstr::{BStr, ByteSlice},
         commit::MessageRef,
@@ -236,11 +235,7 @@ mod summary {
         let actor = SignatureRef {
             name: "name".into(),
             email: "email".into(),
-            time: Time {
-                seconds: 0,
-                offset: 0,
-                sign: Sign::Plus,
-            },
+            time: "0 0000",
         };
         assert_eq!(
             CommitRef {
diff --git a/gix-object/tests/object/commit/mod.rs b/gix-object/tests/object/commit/mod.rs
index 69e272414e8..abc63a191ba 100644
--- a/gix-object/tests/object/commit/mod.rs
+++ b/gix-object/tests/object/commit/mod.rs
@@ -172,7 +172,7 @@ fn invalid() {
     assert_eq!(
         CommitRef::from_bytes(partial_commit).unwrap_err().to_string(),
         if cfg!(feature = "verbose-object-parsing-errors") {
-            "object parsing failed at `1`\nexpected `author <signature>`"
+            "object parsing failed at ``\nexpected `author <signature>`"
         } else {
             "object parsing failed"
         }
diff --git a/gix-object/tests/object/encode/mod.rs b/gix-object/tests/object/encode/mod.rs
index 81cb9c73160..154a2585c12 100644
--- a/gix-object/tests/object/encode/mod.rs
+++ b/gix-object/tests/object/encode/mod.rs
@@ -103,8 +103,7 @@ mod commit {
 }
 
 mod tree {
-    use gix_object::tree::EntryKind;
-    use gix_object::{tree, WriteTo};
+    use gix_object::{tree, tree::EntryKind, WriteTo};
 
     #[test]
     fn write_to_does_not_validate() {
diff --git a/gix-object/tests/object/main.rs b/gix-object/tests/object/main.rs
index b58d6118c18..bf7c8eeea55 100644
--- a/gix-object/tests/object/main.rs
+++ b/gix-object/tests/object/main.rs
@@ -81,8 +81,8 @@ fn fixture_name(kind: &str, path: &str) -> Vec<u8> {
 fn size_in_memory() {
     let actual = std::mem::size_of::<gix_object::Object>();
     assert!(
-        actual <= 264,
-        "{actual} <= 264: Prevent unexpected growth of what should be lightweight objects"
+        actual <= 272,
+        "{actual} <= 272: Prevent unexpected growth of what should be lightweight objects"
     );
 }
 
@@ -90,30 +90,20 @@ fn hex_to_id(hex: &str) -> ObjectId {
     ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")
 }
 
-use gix_date::{time::Sign, SecondsSinceUnixEpoch, Time};
-
-fn signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
+fn signature(time: &str) -> gix_actor::SignatureRef<'_> {
     use gix_object::bstr::ByteSlice;
     gix_actor::SignatureRef {
         name: b"Sebastian Thiel".as_bstr(),
         email: b"sebastian.thiel@icloud.com".as_bstr(),
-        time: Time {
-            seconds,
-            offset: 28800,
-            sign: Sign::Plus,
-        },
+        time,
     }
 }
 
-fn linus_signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
+fn linus_signature(time: &str) -> gix_actor::SignatureRef<'_> {
     use gix_object::bstr::ByteSlice;
     gix_actor::SignatureRef {
         name: b"Linus Torvalds".as_bstr(),
         email: b"torvalds@linux-foundation.org".as_bstr(),
-        time: Time {
-            seconds,
-            offset: -25200,
-            sign: Sign::Minus,
-        },
+        time,
     }
 }
diff --git a/gix-object/tests/object/tag/mod.rs b/gix-object/tests/object/tag/mod.rs
index 801ca29a043..4d37fbe64f9 100644
--- a/gix-object/tests/object/tag/mod.rs
+++ b/gix-object/tests/object/tag/mod.rs
@@ -1,10 +1,10 @@
-use gix_date::time::Sign;
 use gix_object::{bstr::ByteSlice, Kind, TagRef, TagRefIter};
 
 use crate::fixture_name;
 
 mod method {
     use bstr::ByteSlice;
+    use gix_date::parse::TimeBuf;
     use gix_object::TagRef;
     use pretty_assertions::assert_eq;
 
@@ -28,7 +28,8 @@ mod method {
         assert_eq!(target.to_string(), tag.target);
         assert_eq!(target_kind, tag.target_kind);
         assert_eq!(name, tag.name);
-        assert_eq!(tagger.as_ref().map(|s| s.to_ref()), tag.tagger);
+        let mut buf = TimeBuf::default();
+        assert_eq!(tagger.as_ref().map(|s| s.to_ref(&mut buf)), tag.tagger);
         assert_eq!(message, tag.message);
         assert_eq!(pgp_signature.as_ref().map(|s| s.as_bstr()), tag.pgp_signature);
         Ok(())
@@ -45,7 +46,7 @@ mod iter {
         let tag = fixture_name("tag", "empty.txt");
         let tag_iter = TagRefIter::from_bytes(&tag);
         let target_id = hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
-        let tagger = Some(signature(1592381636));
+        let tagger = Some(signature("1592381636 +0800"));
         assert_eq!(
             tag_iter.collect::<Result<Vec<_>, _>>()?,
             vec![
@@ -110,7 +111,7 @@ KLMHist5yj0sw1E4hDTyQa0=
                 },
                 Token::TargetKind(Kind::Commit),
                 Token::Name(b"whitespace".as_bstr()),
-                Token::Tagger(Some(signature(1592382888))),
+                Token::Tagger(Some(signature("1592382888 +0800"))),
                 Token::Body {
                     message: b" \ttab\nnewline\n\nlast-with-trailer\n".as_bstr(),
                     pgp_signature: None
@@ -154,17 +155,13 @@ fn invalid() {
 
 mod from_bytes {
     use gix_actor::SignatureRef;
-    use gix_date::Time;
     use gix_object::{bstr::ByteSlice, Kind, TagRef, WriteTo};
 
-    use crate::{fixture_name, signature, tag::tag_fixture, Sign};
+    use crate::{fixture_name, signature, tag::tag_fixture};
 
     #[test]
     fn signed() -> crate::Result {
-        assert_eq!(
-            TagRef::from_bytes(&fixture_name("tag", "signed.txt"))?,
-            tag_fixture(9000)
-        );
+        assert_eq!(TagRef::from_bytes(&fixture_name("tag", "signed.txt"))?, tag_fixture());
         Ok(())
     }
 
@@ -179,7 +176,7 @@ mod from_bytes {
                 name: b"empty".as_bstr(),
                 target_kind: Kind::Commit,
                 message: b"\n".as_bstr(),
-                tagger: Some(signature(1592381636)),
+                tagger: Some(signature("1592381636 +0800")),
                 pgp_signature: None
             }
         );
@@ -198,7 +195,7 @@ mod from_bytes {
                 name: b"empty".as_bstr(),
                 target_kind: Kind::Commit,
                 message: b"".as_bstr(),
-                tagger: Some(signature(1592381636)),
+                tagger: Some(signature("1592381636 +0800")),
                 pgp_signature: None
             }
         );
@@ -215,7 +212,7 @@ mod from_bytes {
                 name: b"baz".as_bstr(),
                 target_kind: Kind::Commit,
                 message: b"hello\n\nworld".as_bstr(),
-                tagger: Some(signature(1592311808)),
+                tagger: Some(signature("1592311808 +0800")),
                 pgp_signature: None
             }
         );
@@ -263,7 +260,7 @@ KLMHist5yj0sw1E4hDTyQa0=
                 name: b"whitespace".as_bstr(),
                 target_kind: Kind::Commit,
                 message: b" \ttab\nnewline\n\nlast-with-trailer\n".as_bstr(),
-                tagger: Some(signature(1592382888)),
+                tagger: Some(signature("1592382888 +0800")),
                 pgp_signature: None
             }
         );
@@ -282,11 +279,7 @@ KLMHist5yj0sw1E4hDTyQa0=
                 tagger: Some(SignatureRef {
                     name: b"shemminger".as_bstr(),
                     email: b"shemminger".as_bstr(),
-                    time: Time {
-                        seconds: 0,
-                        offset: 0,
-                        sign: Sign::Plus
-                    }
+                    time: "",
                 }),
                 pgp_signature: None
             }
@@ -295,7 +288,7 @@ KLMHist5yj0sw1E4hDTyQa0=
     }
 }
 
-fn tag_fixture(offset: i32) -> TagRef<'static> {
+fn tag_fixture() -> TagRef<'static> {
     TagRef {
         target: b"ffa700b4aca13b80cb6b98a078e7c96804f8e0ec".as_bstr(),
         name: b"1.0.0".as_bstr(),
@@ -324,11 +317,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
         tagger: Some(gix_actor::SignatureRef {
             name: b"Sebastian Thiel".as_bstr(),
             email: b"byronimo@gmail.com".as_bstr(),
-            time: gix_date::Time {
-                seconds: 1528473343,
-                offset,
-                sign: Sign::Plus,
-            },
+            time: "1528473343 +0230",
         }),
     }
 }
diff --git a/gix-object/tests/object/tree/editor.rs b/gix-object/tests/object/tree/editor.rs
index 7f7bc6ccc11..70d73af68f4 100644
--- a/gix-object/tests/object/tree/editor.rs
+++ b/gix-object/tests/object/tree/editor.rs
@@ -1,5 +1,7 @@
-use gix_object::tree::{Entry, EntryKind};
-use gix_object::Tree;
+use gix_object::{
+    tree::{Entry, EntryKind},
+    Tree,
+};
 
 #[test]
 fn from_empty_cursor() -> crate::Result {
@@ -771,12 +773,16 @@ fn from_existing_add() -> crate::Result {
 }
 
 mod utils {
-    use crate::hex_to_id;
+    use std::{
+        cell::{Cell, RefCell},
+        rc::Rc,
+    };
+
     use bstr::{BStr, ByteSlice};
     use gix_hash::ObjectId;
     use gix_object::{Tree, WriteTo};
-    use std::cell::{Cell, RefCell};
-    use std::rc::Rc;
+
+    use crate::hex_to_id;
 
     type TreeStore = Rc<RefCell<gix_hashtable::HashMap<ObjectId, Tree>>>;
     pub(super) struct StorageOdb(TreeStore, Option<gix_odb::Handle>, Cell<usize>);
@@ -937,7 +943,8 @@ mod utils {
         hex_to_id("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb")
     }
 }
-use crate::hex_to_id;
 use utils::{
     any_blob, display_tree, display_tree_with_odb, empty_tree, find_tree, new_inmemory_writes, tree_odb, StorageOdb,
 };
+
+use crate::hex_to_id;
diff --git a/gix-object/tests/object/tree/iter.rs b/gix-object/tests/object/tree/iter.rs
index b4717493a29..264d0f08e39 100644
--- a/gix-object/tests/object/tree/iter.rs
+++ b/gix-object/tests/object/tree/iter.rs
@@ -77,10 +77,11 @@ fn everything() -> crate::Result {
 }
 
 mod lookup_entry {
-    use crate::hex_to_id;
     use gix_object::tree::EntryKind;
     use utils::entry;
 
+    use crate::hex_to_id;
+
     #[test]
     fn top_level_directory() -> crate::Result {
         assert_eq!(
@@ -117,10 +118,10 @@ mod lookup_entry {
     }
 
     mod utils {
-        use crate::hex_to_id;
-
         use gix_object::{tree, FindExt};
 
+        use crate::hex_to_id;
+
         pub(super) fn entry(filename: &str, mode: tree::EntryKind, oid: gix_hash::ObjectId) -> Option<tree::Entry> {
             Some(tree::Entry {
                 mode: mode.into(),
diff --git a/gix-odb/src/memory.rs b/gix-odb/src/memory.rs
index 4058b47e609..6862437f1fc 100644
--- a/gix-odb/src/memory.rs
+++ b/gix-odb/src/memory.rs
@@ -1,10 +1,13 @@
-use crate::find::Header;
-use crate::Cache;
+use std::{
+    cell::RefCell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+    sync::Arc,
+};
+
 use gix_object::Data;
-use std::cell::RefCell;
-use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
-use std::sync::Arc;
+
+use crate::{find::Header, Cache};
 
 /// An object database to read from any implementation but write to memory.
 /// Previously written objects can be returned from memory upon query, which makes the view of objects consistent.
diff --git a/gix-odb/src/store_impls/dynamic/load_index.rs b/gix-odb/src/store_impls/dynamic/load_index.rs
index 1cd09d12e0c..5e768d165fd 100644
--- a/gix-odb/src/store_impls/dynamic/load_index.rs
+++ b/gix-odb/src/store_impls/dynamic/load_index.rs
@@ -165,7 +165,7 @@ impl super::Store {
             }
             if previous_state_id == index.state_id() {
                 let potentially_new_index = self.index.load();
-                if Arc::as_ptr(&potentially_new_index) == Arc::as_ptr(&index) {
+                if std::ptr::eq(Arc::as_ptr(&potentially_new_index), Arc::as_ptr(&index)) {
                     // There isn't a new index with which to retry the whole ordeal, so nothing could be done here.
                     return false;
                 } else {
@@ -392,9 +392,11 @@ impl super::Store {
                 next_index_to_load: index_unchanged
                     .then(|| Arc::clone(&index.next_index_to_load))
                     .unwrap_or_default(),
-                loaded_indices: index_unchanged
-                    .then(|| Arc::clone(&index.loaded_indices))
-                    .unwrap_or_else(|| Arc::new(num_loaded_indices.into())),
+                loaded_indices: if index_unchanged {
+                    Arc::clone(&index.loaded_indices)
+                } else {
+                    Arc::new(num_loaded_indices.into())
+                },
                 num_indices_currently_being_loaded: Default::default(),
             });
             self.index.store(new_index);
diff --git a/gix-odb/tests/odb/memory.rs b/gix-odb/tests/odb/memory.rs
index f9c34a4c9f7..cd0bade0d9b 100644
--- a/gix-odb/tests/odb/memory.rs
+++ b/gix-odb/tests/odb/memory.rs
@@ -1,8 +1,8 @@
-use crate::odb::hex_to_id;
-use gix_object::Write;
-use gix_object::{tree, Exists, FindExt};
+use gix_object::{tree, Exists, FindExt, Write};
 use gix_testtools::tempfile::TempDir;
 
+use crate::odb::hex_to_id;
+
 #[test]
 fn without_memory() -> crate::Result {
     use gix_odb::HeaderExt;
diff --git a/gix-odb/tests/odb/store/loose.rs b/gix-odb/tests/odb/store/loose.rs
index e5b4fee35d6..c43699ab0e9 100644
--- a/gix-odb/tests/odb/store/loose.rs
+++ b/gix-odb/tests/odb/store/loose.rs
@@ -1,6 +1,5 @@
 use std::sync::atomic::AtomicBool;
 
-use gix_date::{time::Sign, SecondsSinceUnixEpoch, Time};
 use gix_features::progress;
 use gix_object::bstr::ByteSlice;
 use gix_odb::loose::Store;
@@ -285,7 +284,7 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
 "
                 .as_bstr(),
             ),
-            tagger: Some(signature(1528473343)),
+            tagger: Some(signature("1528473343 +0200")),
         };
         assert_eq!(o.decode()?.as_tag().expect("tag"), &expected);
         Ok(())
@@ -300,8 +299,8 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
         let expected = CommitRef {
             tree: b"6ba2a0ded519f737fd5b8d5ccfb141125ef3176f".as_bstr(),
             parents: vec![].into(),
-            author: signature(1528473303),
-            committer: signature(1528473303),
+            author: signature("1528473303 +0200"),
+            committer: signature("1528473303 +0200"),
             encoding: None,
             message: b"initial commit\n".as_bstr(),
             extra_headers: vec![(b"gpgsig".as_bstr(), b"-----BEGIN PGP SIGNATURE-----\nComment: GPGTools - https://gpgtools.org\n\niQIzBAABCgAdFiEEw7xSvXbiwjusbsBqZl+Z+p2ZlmwFAlsaptwACgkQZl+Z+p2Z\nlmxXSQ//fj6t7aWoEKeMdFigfj6OXWPUyrRbS0N9kpJeOfA0BIOea/6Jbn8J5qh1\nYRfrySOzHPXR5Y+w4GwLiVas66qyhAbk4yeqZM0JxBjHDyPyRGhjUd3y7WjEa6bj\nP0ACAIkYZQ/Q/LDE3eubmhAwEobBH3nZbwE+/zDIG0i265bD5C0iDumVOiKkSelw\ncr6FZVw1HH+GcabFkeLRZLNGmPqGdbeBwYERqb0U1aRCzV1xLYteoKwyWcYaH8E3\n97z1rwhUO/L7o8WUEJtP3CLB0zuocslMxskf6bCeubBnRNJ0YrRmxGarxCP3vn4D\n3a/MwECnl6mnUU9t+OnfvrzLDN73rlq8iasUq6hGe7Sje7waX6b2UGpxHqwykmXg\nVimD6Ah7svJanHryfJn38DvJW/wOMqmAnSUAp+Y8W9EIe0xVntCmtMyoKuqBoY7T\nJlZ1kHJte6ELIM5JOY9Gx7D0ZCSKZJQqyjoqtl36dsomT0I78/+7QS1DP4S6XB7d\nc3BYH0JkW81p7AAFbE543ttN0Z4wKXErMFqUKnPZUIEuybtlNYV+krRdfDBWQysT\n3MBebjguVQ60oGs06PzeYBosKGQrHggAcwduLFuqXhLTJqN4UQ18RkE0vbtG3YA0\n+XtZQM13vURdfwFI5qitAGgw4EzPVrkWWzApzLCrRPEMbvP+b9A=\n=2qqN\n-----END PGP SIGNATURE-----\n".as_bstr().into())]
@@ -429,14 +428,10 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 }
 
-fn signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
+fn signature(time: &str) -> gix_actor::SignatureRef<'_> {
     gix_actor::SignatureRef {
         name: b"Sebastian Thiel".as_bstr(),
         email: b"byronimo@gmail.com".as_bstr(),
-        time: Time {
-            seconds,
-            offset: 7200,
-            sign: Sign::Plus,
-        },
+        time,
     }
 }
diff --git a/gix-pack/src/cache/delta/tree.rs b/gix-pack/src/cache/delta/tree.rs
index 9e7873b3923..f93608727f4 100644
--- a/gix-pack/src/cache/delta/tree.rs
+++ b/gix-pack/src/cache/delta/tree.rs
@@ -228,9 +228,10 @@ mod tests {
     }
 
     mod size {
-        use super::super::Item;
         use gix_testtools::size_ok;
 
+        use super::super::Item;
+
         #[test]
         fn size_of_pack_tree_item() {
             let actual = std::mem::size_of::<[Item<()>; 7_500_000]>();
diff --git a/gix-pack/src/cache/lru.rs b/gix-pack/src/cache/lru.rs
index 1e4a6ba7c62..ab223ba7d9b 100644
--- a/gix-pack/src/cache/lru.rs
+++ b/gix-pack/src/cache/lru.rs
@@ -2,10 +2,12 @@ use super::DecodeEntry;
 
 #[cfg(feature = "pack-cache-lru-dynamic")]
 mod memory {
+    use std::num::NonZeroUsize;
+
+    use clru::WeightScale;
+
     use super::DecodeEntry;
     use crate::cache::set_vec_to_slice;
-    use clru::WeightScale;
-    use std::num::NonZeroUsize;
 
     struct Entry {
         data: Vec<u8>,
diff --git a/gix-pack/src/cache/object.rs b/gix-pack/src/cache/object.rs
index 515c8f2c720..05e2230e242 100644
--- a/gix-pack/src/cache/object.rs
+++ b/gix-pack/src/cache/object.rs
@@ -4,10 +4,12 @@ use crate::cache;
 
 #[cfg(feature = "object-cache-dynamic")]
 mod memory {
-    use crate::{cache, cache::set_vec_to_slice};
-    use clru::WeightScale;
     use std::num::NonZeroUsize;
 
+    use clru::WeightScale;
+
+    use crate::{cache, cache::set_vec_to_slice};
+
     struct Entry {
         data: Vec<u8>,
         kind: gix_object::Kind,
diff --git a/gix-pack/src/data/file/decode/entry.rs b/gix-pack/src/data/file/decode/entry.rs
index eb09f456b1f..50030ac705b 100644
--- a/gix-pack/src/data/file/decode/entry.rs
+++ b/gix-pack/src/data/file/decode/entry.rs
@@ -419,9 +419,10 @@ impl File {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use gix_testtools::size_ok;
 
+    use super::*;
+
     #[test]
     fn size_of_decode_entry_outcome() {
         let actual = std::mem::size_of::<Outcome>();
diff --git a/gix-pack/src/data/output/bytes.rs b/gix-pack/src/data/output/bytes.rs
index 39f7a1d8a05..c6ee8e5f1ee 100644
--- a/gix-pack/src/data/output/bytes.rs
+++ b/gix-pack/src/data/output/bytes.rs
@@ -1,7 +1,6 @@
 use std::io::Write;
 
-use crate::data::output;
-use crate::exact_vec;
+use crate::{data::output, exact_vec};
 
 /// The error returned by `next()` in the [`FromEntriesIter`] iterator.
 #[allow(missing_docs)]
diff --git a/gix-pack/src/index/encode.rs b/gix-pack/src/index/encode.rs
index 58f63cea954..815b134e994 100644
--- a/gix-pack/src/index/encode.rs
+++ b/gix-pack/src/index/encode.rs
@@ -36,9 +36,10 @@ pub(crate) fn fanout(iter: &mut dyn ExactSizeIterator<Item = u8>) -> [u32; 256]
 mod function {
     use std::io;
 
+    use gix_features::progress::{self, DynNestedProgress};
+
     use super::{fanout, HIGH_BIT, LARGE_OFFSET_THRESHOLD};
     use crate::index::V2_SIGNATURE;
-    use gix_features::progress::{self, DynNestedProgress};
 
     struct Count<W> {
         bytes: u64,
diff --git a/gix-pack/src/index/util.rs b/gix-pack/src/index/util.rs
index 2ffebfe25b1..26caba835c3 100644
--- a/gix-pack/src/index/util.rs
+++ b/gix-pack/src/index/util.rs
@@ -1,8 +1,9 @@
 use std::time::Instant;
 
-use crate::exact_vec;
 use gix_features::progress::{self, Progress};
 
+use crate::exact_vec;
+
 pub(crate) fn index_entries_sorted_by_offset_ascending(
     idx: &crate::index::File,
     progress: &mut dyn Progress,
diff --git a/gix-path/src/convert.rs b/gix-path/src/convert.rs
index a33a91e9e24..000deb3798b 100644
--- a/gix-path/src/convert.rs
+++ b/gix-path/src/convert.rs
@@ -1,8 +1,7 @@
-use std::path::Component;
 use std::{
     borrow::Cow,
     ffi::{OsStr, OsString},
-    path::{Path, PathBuf},
+    path::{Component, Path, PathBuf},
 };
 
 use bstr::{BStr, BString};
diff --git a/gix-path/src/env/auxiliary.rs b/gix-path/src/env/auxiliary.rs
index 02169dc5b96..078cd51edaf 100644
--- a/gix-path/src/env/auxiliary.rs
+++ b/gix-path/src/env/auxiliary.rs
@@ -1,5 +1,7 @@
-use std::ffi::OsString;
-use std::path::{Path, PathBuf};
+use std::{
+    ffi::OsString,
+    path::{Path, PathBuf},
+};
 
 use once_cell::sync::Lazy;
 
diff --git a/gix-path/src/env/git/mod.rs b/gix-path/src/env/git/mod.rs
index d2cb9b60b52..e92be9631cc 100644
--- a/gix-path/src/env/git/mod.rs
+++ b/gix-path/src/env/git/mod.rs
@@ -1,6 +1,8 @@
-use std::env;
-use std::path::{Path, PathBuf};
-use std::process::{Command, Stdio};
+use std::{
+    env,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
 
 use bstr::{BStr, BString, ByteSlice};
 use once_cell::sync::Lazy;
diff --git a/gix-path/src/env/git/tests.rs b/gix-path/src/env/git/tests.rs
index 99f3377fd3a..cb5820aea6d 100644
--- a/gix-path/src/env/git/tests.rs
+++ b/gix-path/src/env/git/tests.rs
@@ -2,15 +2,21 @@ use std::path::Path;
 
 #[cfg(windows)]
 mod locations {
-    use std::ffi::{OsStr, OsString};
-    use std::io::ErrorKind;
-    use std::path::{Path, PathBuf};
+    use std::{
+        ffi::{OsStr, OsString},
+        io::ErrorKind,
+        path::{Path, PathBuf},
+    };
 
     use known_folders::{get_known_folder_path, KnownFolder};
-    use windows::core::{Result as WindowsResult, BOOL};
-    use windows::Win32::System::Threading::{GetCurrentProcess, IsWow64Process};
-    use winreg::enums::{HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE};
-    use winreg::RegKey;
+    use windows::{
+        core::{Result as WindowsResult, BOOL},
+        Win32::System::Threading::{GetCurrentProcess, IsWow64Process},
+    };
+    use winreg::{
+        enums::{HKEY_LOCAL_MACHINE, KEY_QUERY_VALUE},
+        RegKey,
+    };
 
     macro_rules! var_os_stub {
         { $($name:expr => $value:expr),* $(,)? } => {
@@ -359,10 +365,11 @@ mod locations {
 mod exe_info {
     use std::path::{Path, PathBuf};
 
-    use crate::env::git::{exe_info, NULL_DEVICE};
     use gix_testtools::tempfile;
     use serial_test::serial;
 
+    use crate::env::git::{exe_info, NULL_DEVICE};
+
     /// Wrapper for a valid path to a plausible location, kept from accidentally existing (until drop).
     #[derive(Debug)]
     struct NonexistentLocation {
diff --git a/gix-path/src/env/mod.rs b/gix-path/src/env/mod.rs
index 1878e1317ba..a822054ea7e 100644
--- a/gix-path/src/env/mod.rs
+++ b/gix-path/src/env/mod.rs
@@ -1,5 +1,7 @@
-use std::ffi::{OsStr, OsString};
-use std::path::{Path, PathBuf};
+use std::{
+    ffi::{OsStr, OsString},
+    path::{Path, PathBuf},
+};
 
 use bstr::{BString, ByteSlice};
 use once_cell::sync::Lazy;
diff --git a/gix-path/src/relative_path.rs b/gix-path/src/relative_path.rs
index 2ee5ec222e3..c0b286d9054 100644
--- a/gix-path/src/relative_path.rs
+++ b/gix-path/src/relative_path.rs
@@ -1,12 +1,9 @@
-use bstr::BStr;
-use bstr::BString;
-use bstr::ByteSlice;
-use gix_validate::path::component::Options;
 use std::path::Path;
 
-use crate::os_str_into_bstr;
-use crate::try_from_bstr;
-use crate::try_from_byte_slice;
+use bstr::{BStr, BString, ByteSlice};
+use gix_validate::path::component::Options;
+
+use crate::{os_str_into_bstr, try_from_bstr, try_from_byte_slice};
 
 pub(super) mod types {
     use bstr::{BStr, ByteSlice};
diff --git a/gix-path/tests/path/realpath.rs b/gix-path/tests/path/realpath.rs
index 92e14685c59..22a13845362 100644
--- a/gix-path/tests/path/realpath.rs
+++ b/gix-path/tests/path/realpath.rs
@@ -1,10 +1,11 @@
-use std::path::{Path, PathBuf};
-use std::time::Duration;
+use std::{
+    path::{Path, PathBuf},
+    time::Duration,
+};
 
 use bstr::ByteVec;
-use gix_testtools::tempfile;
-
 use gix_path::{realpath::Error, realpath_opts};
+use gix_testtools::tempfile;
 
 #[test]
 fn fuzzed_timeout() -> crate::Result {
diff --git a/gix-path/tests/path/relative_path.rs b/gix-path/tests/path/relative_path.rs
index c8d880b3d71..c475ccb7079 100644
--- a/gix-path/tests/path/relative_path.rs
+++ b/gix-path/tests/path/relative_path.rs
@@ -1,6 +1,5 @@
 use bstr::{BStr, BString};
-use gix_path::relative_path::Error;
-use gix_path::RelativePath;
+use gix_path::{relative_path::Error, RelativePath};
 
 #[cfg(not(windows))]
 #[test]
diff --git a/gix-pathspec/src/search/matching.rs b/gix-pathspec/src/search/matching.rs
index 69f62a91c6c..075055d899a 100644
--- a/gix-pathspec/src/search/matching.rs
+++ b/gix-pathspec/src/search/matching.rs
@@ -1,10 +1,8 @@
 use bstr::{BStr, BString, ByteSlice};
 use gix_glob::pattern::Case;
 
-use crate::search::MatchKind;
-use crate::search::MatchKind::*;
 use crate::{
-    search::{Match, Spec},
+    search::{Match, MatchKind, MatchKind::*, Spec},
     MagicSignature, Pattern, Search, SearchMode,
 };
 
diff --git a/gix-pathspec/src/search/mod.rs b/gix-pathspec/src/search/mod.rs
index 54c4ea58a8a..e9a3ec1a24d 100644
--- a/gix-pathspec/src/search/mod.rs
+++ b/gix-pathspec/src/search/mod.rs
@@ -1,6 +1,6 @@
+use std::{borrow::Cow, path::Path};
+
 use bstr::{BStr, ByteSlice};
-use std::borrow::Cow;
-use std::path::Path;
 
 use crate::{MagicSignature, Pattern, Search};
 
diff --git a/gix-pathspec/tests/search/mod.rs b/gix-pathspec/tests/search/mod.rs
index c1c0bac88ad..e645e48cb21 100644
--- a/gix-pathspec/tests/search/mod.rs
+++ b/gix-pathspec/tests/search/mod.rs
@@ -1,6 +1,7 @@
+use std::path::Path;
+
 use bstr::BStr;
 use gix_pathspec::search::MatchKind::*;
-use std::path::Path;
 
 #[test]
 fn directories() -> crate::Result {
diff --git a/gix-prompt/src/lib.rs b/gix-prompt/src/lib.rs
index dba6cf80405..60d4eb7c556 100644
--- a/gix-prompt/src/lib.rs
+++ b/gix-prompt/src/lib.rs
@@ -43,7 +43,10 @@ pub fn ask(prompt: &str, opts: &Options<'_>) -> Result<String, Error> {
                     return Ok(stdout);
                 }
             }
-            Err(err) => eprintln!("Cannot run askpass program: {askpass:?} with error: {err}"),
+            Err(err) => eprintln!(
+                "Cannot run askpass program: '{askpass}' with error: {err}",
+                askpass = askpass.display()
+            ),
         }
     }
     imp::ask(prompt, opts)
diff --git a/gix-protocol/src/fetch/function.rs b/gix-protocol/src/fetch/function.rs
index 8ae294167cc..1ac524cd21b 100644
--- a/gix-protocol/src/fetch/function.rs
+++ b/gix-protocol/src/fetch/function.rs
@@ -1,10 +1,16 @@
-use crate::fetch::{
-    negotiate, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags,
+use std::{
+    path::Path,
+    sync::atomic::{AtomicBool, Ordering},
 };
-use crate::{fetch::Arguments, transport::packetline::read::ProgressAction};
+
 use gix_features::progress::DynNestedProgress;
-use std::path::Path;
-use std::sync::atomic::{AtomicBool, Ordering};
+
+use crate::{
+    fetch::{
+        negotiate, Arguments, Context, Error, Negotiate, NegotiateOutcome, Options, Outcome, ProgressId, Shallow, Tags,
+    },
+    transport::packetline::read::ProgressAction,
+};
 
 /// Perform one fetch operation, relying on a `transport`.
 /// `negotiate` is used to run the negotiation of objects that should be contained in the pack, *if* one is to be received.
diff --git a/gix-protocol/src/fetch/negotiate.rs b/gix-protocol/src/fetch/negotiate.rs
index 54c8514d2cf..dcefaa6760c 100644
--- a/gix-protocol/src/fetch/negotiate.rs
+++ b/gix-protocol/src/fetch/negotiate.rs
@@ -5,10 +5,11 @@
 //! 1. [`mark_complete_and_common_ref()`] - initialize the [`negotiator`](gix_negotiate::Negotiator) with all state known on the remote.
 //! 2. [`add_wants()`] is called if the call at 1) returned [`Action::MustNegotiate`].
 //! 3. [`one_round()`] is called for each negotiation round, providing information if the negotiation is done.
+use std::borrow::Cow;
+
 use gix_date::SecondsSinceUnixEpoch;
 use gix_negotiate::Flags;
 use gix_ref::file::ReferenceExt;
-use std::borrow::Cow;
 
 use crate::fetch::{refmap, RefMap, Shallow, Tags};
 
diff --git a/gix-protocol/src/fetch/refmap/init.rs b/gix-protocol/src/fetch/refmap/init.rs
index 5efaac44c25..7db8ea86dfd 100644
--- a/gix-protocol/src/fetch/refmap/init.rs
+++ b/gix-protocol/src/fetch/refmap/init.rs
@@ -1,12 +1,17 @@
 use std::collections::HashSet;
 
-use crate::fetch;
-use crate::fetch::refmap::{Mapping, Source, SpecIndex};
-use crate::fetch::RefMap;
-use crate::transport::client::Transport;
 use bstr::{BString, ByteVec};
 use gix_features::progress::Progress;
 
+use crate::{
+    fetch,
+    fetch::{
+        refmap::{Mapping, Source, SpecIndex},
+        RefMap,
+    },
+    transport::client::Transport,
+};
+
 /// The error returned by [`RefMap::new()`].
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-protocol/src/fetch/response/async_io.rs b/gix-protocol/src/fetch/response/async_io.rs
index eea71bb6086..42be8b6e606 100644
--- a/gix-protocol/src/fetch/response/async_io.rs
+++ b/gix-protocol/src/fetch/response/async_io.rs
@@ -4,8 +4,7 @@ use gix_transport::{client, Protocol};
 
 use crate::fetch::{
     response,
-    response::shallow_update_from_line,
-    response::{Acknowledgement, ShallowUpdate, WantedRef},
+    response::{shallow_update_from_line, Acknowledgement, ShallowUpdate, WantedRef},
     Response,
 };
 
diff --git a/gix-protocol/src/fetch/response/blocking_io.rs b/gix-protocol/src/fetch/response/blocking_io.rs
index 5d3c2f88e67..4143e93fb7f 100644
--- a/gix-protocol/src/fetch/response/blocking_io.rs
+++ b/gix-protocol/src/fetch/response/blocking_io.rs
@@ -2,10 +2,9 @@ use std::io;
 
 use gix_transport::{client, Protocol};
 
-use crate::fetch::response::shallow_update_from_line;
 use crate::fetch::{
     response,
-    response::{Acknowledgement, ShallowUpdate, WantedRef},
+    response::{shallow_update_from_line, Acknowledgement, ShallowUpdate, WantedRef},
     Response,
 };
 
diff --git a/gix-protocol/src/fetch/response/mod.rs b/gix-protocol/src/fetch/response/mod.rs
index f5b328b8bad..5a85fcb7c35 100644
--- a/gix-protocol/src/fetch/response/mod.rs
+++ b/gix-protocol/src/fetch/response/mod.rs
@@ -1,8 +1,7 @@
 use bstr::BString;
 use gix_transport::{client, Protocol};
 
-use crate::command::Feature;
-use crate::fetch::Response;
+use crate::{command::Feature, fetch::Response};
 
 /// The error returned in the [response module][crate::fetch::response].
 #[derive(Debug, thiserror::Error)]
diff --git a/gix-protocol/src/fetch/types.rs b/gix-protocol/src/fetch/types.rs
index fbc40b9239a..db737b5bcde 100644
--- a/gix-protocol/src/fetch/types.rs
+++ b/gix-protocol/src/fetch/types.rs
@@ -1,6 +1,7 @@
-use crate::fetch::response::{Acknowledgement, ShallowUpdate, WantedRef};
 use std::path::PathBuf;
 
+use crate::fetch::response::{Acknowledgement, ShallowUpdate, WantedRef};
+
 /// Options for use in [`fetch()`](`crate::fetch()`)
 #[derive(Debug, Clone)]
 pub struct Options<'a> {
@@ -38,8 +39,10 @@ pub struct Context<'a, T> {
 
 #[cfg(feature = "fetch")]
 mod with_fetch {
-    use crate::fetch;
-    use crate::fetch::{negotiate, refmap};
+    use crate::{
+        fetch,
+        fetch::{negotiate, refmap},
+    };
 
     /// For use in [`fetch`](crate::fetch()).
     pub struct NegotiateContext<'a, 'b, 'c, Objects, Alternates, AlternatesOut, AlternatesErr, Find>
diff --git a/gix-protocol/src/handshake/refs/async_io.rs b/gix-protocol/src/handshake/refs/async_io.rs
index 5b9dfcee7f3..996b83bca69 100644
--- a/gix-protocol/src/handshake/refs/async_io.rs
+++ b/gix-protocol/src/handshake/refs/async_io.rs
@@ -1,5 +1,7 @@
-use crate::fetch::response::ShallowUpdate;
-use crate::handshake::{refs, refs::parse::Error, Ref};
+use crate::{
+    fetch::response::ShallowUpdate,
+    handshake::{refs, refs::parse::Error, Ref},
+};
 
 /// Parse refs from the given input line by line. Protocol V2 is required for this to succeed.
 pub async fn from_v2_refs(in_refs: &mut dyn gix_transport::client::ReadlineBufRead) -> Result<Vec<Ref>, Error> {
diff --git a/gix-protocol/src/handshake/refs/blocking_io.rs b/gix-protocol/src/handshake/refs/blocking_io.rs
index ed7e49a312b..151f769586e 100644
--- a/gix-protocol/src/handshake/refs/blocking_io.rs
+++ b/gix-protocol/src/handshake/refs/blocking_io.rs
@@ -1,5 +1,7 @@
-use crate::fetch::response::ShallowUpdate;
-use crate::handshake::{refs, refs::parse::Error, Ref};
+use crate::{
+    fetch::response::ShallowUpdate,
+    handshake::{refs, refs::parse::Error, Ref},
+};
 
 /// Parse refs from the given input line by line. Protocol V2 is required for this to succeed.
 pub fn from_v2_refs(in_refs: &mut dyn gix_transport::client::ReadlineBufRead) -> Result<Vec<Ref>, Error> {
diff --git a/gix-protocol/src/handshake/refs/shared.rs b/gix-protocol/src/handshake/refs/shared.rs
index a2848c64fc5..7249110b17d 100644
--- a/gix-protocol/src/handshake/refs/shared.rs
+++ b/gix-protocol/src/handshake/refs/shared.rs
@@ -1,7 +1,10 @@
-use crate::fetch::response::ShallowUpdate;
-use crate::handshake::{refs::parse::Error, Ref};
 use bstr::{BStr, BString, ByteSlice};
 
+use crate::{
+    fetch::response::ShallowUpdate,
+    handshake::{refs::parse::Error, Ref},
+};
+
 impl From<InternalRef> for Ref {
     fn from(v: InternalRef) -> Self {
         match v {
diff --git a/gix-protocol/tests/protocol/command.rs b/gix-protocol/tests/protocol/command.rs
index 9f878188d32..c09e16252a7 100644
--- a/gix-protocol/tests/protocol/command.rs
+++ b/gix-protocol/tests/protocol/command.rs
@@ -8,9 +8,10 @@ mod v1 {
     const GITHUB_CAPABILITIES: &str = "multi_ack thin-pack side-band ofs-delta shallow deepen-since deepen-not deepen-relative no-progress include-tag allow-tip-sha1-in-want allow-reachable-sha1-in-want no-done symref=HEAD:refs/heads/main filter agent=git/github-gdf51a71f0236";
     mod fetch {
         mod default_features {
-            use super::super::{capabilities, GITHUB_CAPABILITIES};
             use gix_protocol::Command;
 
+            use super::super::{capabilities, GITHUB_CAPABILITIES};
+
             #[test]
             fn it_chooses_the_best_multi_ack_and_sideband() {
                 assert_eq!(
@@ -58,9 +59,10 @@ mod v2 {
 
     mod fetch {
         mod default_features {
-            use super::super::capabilities;
             use gix_protocol::Command;
 
+            use super::super::capabilities;
+
             #[test]
             fn all_features() {
                 assert_eq!(
@@ -78,9 +80,9 @@ mod v2 {
 
         mod initial_arguments {
             use bstr::ByteSlice;
+            use gix_protocol::Command;
 
             use super::super::capabilities;
-            use gix_protocol::Command;
 
             #[test]
             fn for_all_features() {
@@ -101,9 +103,10 @@ mod v2 {
 
     mod ls_refs {
         mod default_features {
-            use super::super::capabilities;
             use gix_protocol::Command;
 
+            use super::super::capabilities;
+
             #[test]
             fn default_as_there_are_no_features() {
                 assert_eq!(
@@ -118,9 +121,9 @@ mod v2 {
 
         mod validate {
             use bstr::ByteSlice;
+            use gix_protocol::Command;
 
             use super::super::capabilities;
-            use gix_protocol::Command;
 
             #[test]
             fn ref_prefixes_can_always_be_used() {
diff --git a/gix-protocol/tests/protocol/fetch/_impl.rs b/gix-protocol/tests/protocol/fetch/_impl.rs
index 8570e1809fd..c4171e20e80 100644
--- a/gix-protocol/tests/protocol/fetch/_impl.rs
+++ b/gix-protocol/tests/protocol/fetch/_impl.rs
@@ -2,16 +2,16 @@ mod fetch_fn {
     use std::borrow::Cow;
 
     use gix_features::progress::NestedProgress;
-    use gix_transport::client;
-    use maybe_async::maybe_async;
-
-    use super::{Action, Delegate};
-    use crate::fetch::Error;
     use gix_protocol::{
         credentials,
         fetch::{Arguments, Response},
         indicate_end_of_interaction, Command,
     };
+    use gix_transport::client;
+    use maybe_async::maybe_async;
+
+    use super::{Action, Delegate};
+    use crate::fetch::Error;
 
     /// A way to indicate how to treat the connection underlying the transport, potentially allowing to reuse it.
     #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
@@ -197,13 +197,12 @@ mod delegate {
     };
 
     use bstr::BString;
-    use gix_transport::client::Capabilities;
-
-    use gix_protocol::ls_refs;
     use gix_protocol::{
         fetch::{Arguments, Response},
         handshake::Ref,
+        ls_refs,
     };
+    use gix_transport::client::Capabilities;
 
     /// Defines what to do next after certain [`Delegate`] operations.
     #[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
@@ -377,9 +376,9 @@ mod delegate {
         };
 
         use gix_features::progress::NestedProgress;
+        use gix_protocol::{fetch::Response, handshake::Ref};
 
         use super::DelegateBlocking;
-        use gix_protocol::{fetch::Response, handshake::Ref};
 
         /// The protocol delegate is the bare minimal interface needed to fully control the [`fetch`][gix_protocol::fetch()] operation.
         ///
@@ -438,9 +437,9 @@ mod delegate {
         use async_trait::async_trait;
         use futures_io::AsyncBufRead;
         use gix_features::progress::NestedProgress;
+        use gix_protocol::{fetch::Response, handshake::Ref};
 
         use super::DelegateBlocking;
-        use gix_protocol::{fetch::Response, handshake::Ref};
 
         /// The protocol delegate is the bare minimal interface needed to fully control the [`fetch`][gix_protocol::fetch()] operation.
         ///
diff --git a/gix-protocol/tests/protocol/fetch/mod.rs b/gix-protocol/tests/protocol/fetch/mod.rs
index ab6f1cc2a9a..355afbb2850 100644
--- a/gix-protocol/tests/protocol/fetch/mod.rs
+++ b/gix-protocol/tests/protocol/fetch/mod.rs
@@ -5,7 +5,6 @@ use gix_protocol::{
     fetch::{Arguments, Response},
     handshake, ls_refs,
 };
-
 use gix_transport::client::Capabilities;
 
 use crate::fixture_bytes;
@@ -16,9 +15,8 @@ use _impl::{Action, DelegateBlocking};
 mod error {
     use std::io;
 
-    use gix_transport::client;
-
     use gix_protocol::{fetch::response, handshake, ls_refs};
+    use gix_transport::client;
 
     /// The error used in [`fetch()`][crate::fetch()].
     #[derive(Debug, thiserror::Error)]
diff --git a/gix-protocol/tests/protocol/fetch/v1.rs b/gix-protocol/tests/protocol/fetch/v1.rs
index dede20e15be..751cb3300cf 100644
--- a/gix-protocol/tests/protocol/fetch/v1.rs
+++ b/gix-protocol/tests/protocol/fetch/v1.rs
@@ -1,10 +1,9 @@
-use crate::fetch::_impl::FetchConnection;
 use bstr::ByteSlice;
 use gix_features::progress;
 use gix_protocol::handshake;
 use gix_transport::Protocol;
 
-use crate::fetch::{helper_unused, oid, transport, CloneDelegate, LsRemoteDelegate};
+use crate::fetch::{_impl::FetchConnection, helper_unused, oid, transport, CloneDelegate, LsRemoteDelegate};
 
 #[maybe_async::test(feature = "blocking-client", async(feature = "async-client", async_std::test))]
 async fn clone() -> crate::Result {
diff --git a/gix-ref/src/lib.rs b/gix-ref/src/lib.rs
index a982b9bf581..a564d0f6488 100644
--- a/gix-ref/src/lib.rs
+++ b/gix-ref/src/lib.rs
@@ -103,8 +103,9 @@ pub mod store {
     ///
     #[path = "general/handle/mod.rs"]
     mod handle;
-    use crate::file;
     pub use handle::find;
+
+    use crate::file;
 }
 
 /// The git reference store.
diff --git a/gix-ref/src/raw.rs b/gix-ref/src/raw.rs
index e6da3201bc9..ccbf33439aa 100644
--- a/gix-ref/src/raw.rs
+++ b/gix-ref/src/raw.rs
@@ -93,9 +93,10 @@ mod access {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use gix_testtools::size_ok;
 
+    use super::*;
+
     #[test]
     fn size_of_reference() {
         let actual = std::mem::size_of::<Reference>();
diff --git a/gix-ref/src/store/file/find.rs b/gix-ref/src/store/file/find.rs
index 3554f0c90f0..09d0d960ed2 100644
--- a/gix-ref/src/store/file/find.rs
+++ b/gix-ref/src/store/file/find.rs
@@ -6,9 +6,9 @@ use std::{
 
 pub use error::Error;
 
-use crate::name::is_pseudo_ref;
 use crate::{
     file,
+    name::is_pseudo_ref,
     store_impl::{file::loose, packed},
     BStr, BString, FullNameRef, PartialName, PartialNameRef, Reference,
 };
diff --git a/gix-ref/src/store/file/log/line.rs b/gix-ref/src/store/file/log/line.rs
index 255001ff6b4..f07deff2306 100644
--- a/gix-ref/src/store/file/log/line.rs
+++ b/gix-ref/src/store/file/log/line.rs
@@ -73,7 +73,6 @@ impl<'a> From<LineRef<'a>> for Line {
 
 ///
 pub mod decode {
-    use crate::{file::log::LineRef, parse::hex_hash};
     use gix_object::bstr::{BStr, ByteSlice};
     use winnow::{
         combinator::{alt, eof, fail, opt, preceded, terminated},
@@ -82,6 +81,8 @@ pub mod decode {
         token::{rest, take_while},
     };
 
+    use crate::{file::log::LineRef, parse::hex_hash};
+
     ///
     mod error {
         use gix_object::bstr::{BString, ByteSlice};
@@ -190,7 +191,6 @@ pub mod decode {
     #[cfg(test)]
     mod test {
         use super::*;
-        use gix_date::{time::Sign, Time};
 
         /// Convert a hexadecimal hash into its corresponding `ObjectId` or _panic_.
         fn hex_to_oid(hex: &str) -> gix_hash::ObjectId {
@@ -250,11 +250,7 @@ pub mod decode {
                         signature: gix_actor::SignatureRef {
                             name: b"name".as_bstr(),
                             email: b"foo@example.com".as_bstr(),
-                            time: Time {
-                                seconds: 1234567890,
-                                offset: 0,
-                                sign: Sign::Minus
-                            }
+                            time: "1234567890 -0000"
                         },
                         message: b"".as_bstr(),
                     }
@@ -278,11 +274,7 @@ pub mod decode {
                     signature: gix_actor::SignatureRef {
                         name: b"Sebastian Thiel".as_bstr(),
                         email: b"foo@example.com".as_bstr(),
-                        time: Time {
-                            seconds: 1618030561,
-                            offset: 28800,
-                            sign: Sign::Plus,
-                        },
+                        time: "1618030561 +0800",
                     },
                     message: b"pull --ff-only: Fast-forward".as_bstr(),
                 };
diff --git a/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs b/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
index 1e3de83175f..b9366bb16ba 100644
--- a/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
+++ b/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
@@ -1,5 +1,5 @@
 use gix_actor::Signature;
-use gix_date::{time::Sign, Time};
+use gix_date::parse::TimeBuf;
 use gix_object::bstr::ByteSlice;
 use gix_testtools::tempfile::TempDir;
 
@@ -57,17 +57,13 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append
         let committer = Signature {
             name: "committer".into(),
             email: "committer@example.com".into(),
-            time: Time {
-                seconds: 1234,
-                offset: 1800,
-                sign: Sign::Plus,
-            },
+            time: gix_date::parse_header("1234 +0800").unwrap(),
         };
         store.reflog_create_or_append(
             full_name,
             None,
             &new,
-            committer.to_ref().into(),
+            committer.to_ref(&mut TimeBuf::default()).into(),
             b"the message".as_bstr(),
             false,
         )?;
@@ -85,11 +81,12 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append
                     }]
                 );
                 let previous = hex_to_id("0000000000000000000000111111111111111111");
+                buf.clear();
                 store.reflog_create_or_append(
                     full_name,
                     Some(previous),
                     &new,
-                    committer.to_ref().into(),
+                    committer.to_ref(&mut TimeBuf::default()).into(),
                     b"next message".as_bstr(),
                     false,
                 )?;
@@ -121,11 +118,12 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append
         let directory_in_place_of_reflog = reflog_path.join("empty-a").join("empty-b");
         std::fs::create_dir_all(directory_in_place_of_reflog)?;
 
+        buf.clear();
         store.reflog_create_or_append(
             full_name,
             None,
             &new,
-            committer.to_ref().into(),
+            committer.to_ref(&mut TimeBuf::default()).into(),
             b"more complicated reflog creation".as_bstr(),
             false,
         )?;
diff --git a/gix-ref/src/store/file/overlay_iter.rs b/gix-ref/src/store/file/overlay_iter.rs
index bd5ca365201..d6c3b5ae8c8 100644
--- a/gix-ref/src/store/file/overlay_iter.rs
+++ b/gix-ref/src/store/file/overlay_iter.rs
@@ -6,15 +6,15 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use gix_object::bstr::ByteSlice;
+use gix_path::RelativePath;
+
 use crate::{
     file::{loose, loose::iter::SortedLoosePaths},
     store_impl::{file, packed},
     BStr, FullName, Namespace, Reference,
 };
 
-use gix_object::bstr::ByteSlice;
-use gix_path::RelativePath;
-
 /// An iterator stepping through sorted input of loose references and packed references, preferring loose refs over otherwise
 /// equivalent packed references.
 ///
diff --git a/gix-ref/src/store/file/raw_ext.rs b/gix-ref/src/store/file/raw_ext.rs
index ab6d1735784..5ec7aef7538 100644
--- a/gix-ref/src/store/file/raw_ext.rs
+++ b/gix-ref/src/store/file/raw_ext.rs
@@ -1,12 +1,13 @@
 use std::collections::BTreeSet;
 
+use gix_hash::ObjectId;
+
 use crate::{
     packed, peel,
     raw::Reference,
     store_impl::{file, file::log},
     Target,
 };
-use gix_hash::ObjectId;
 
 pub trait Sealed {}
 impl Sealed for crate::Reference {}
diff --git a/gix-ref/src/store/packed/transaction.rs b/gix-ref/src/store/packed/transaction.rs
index ece3498aa53..847466b0c46 100644
--- a/gix-ref/src/store/packed/transaction.rs
+++ b/gix-ref/src/store/packed/transaction.rs
@@ -1,5 +1,4 @@
-use std::borrow::Cow;
-use std::{fmt::Formatter, io::Write};
+use std::{borrow::Cow, fmt::Formatter, io::Write};
 
 use crate::{
     file,
diff --git a/gix-ref/tests/refs/file/log.rs b/gix-ref/tests/refs/file/log.rs
index 2efcb263278..697d18e2210 100644
--- a/gix-ref/tests/refs/file/log.rs
+++ b/gix-ref/tests/refs/file/log.rs
@@ -38,7 +38,7 @@ mod line {
             let line = log::LineRef::from_bytes(b"7b114132d03c468a9cd97836901553658c9792de 306cdbab5457c323d1201aa8a59b3639f600a758 First Last <first.last@example.com> 1727013187 +0200\trebase (pick): Replace Into<Range<u32>> by From<LineRange>")?;
             assert_eq!(line.signature.name, "First Last");
             assert_eq!(line.signature.email, "first.last@example.com");
-            assert_eq!(line.signature.time.seconds, 1727013187);
+            assert_eq!(line.signature.seconds(), 1727013187);
             assert_eq!(
                 line.message,
                 "rebase (pick): Replace Into<Range<u32>> by From<LineRange>"
@@ -107,10 +107,10 @@ mod iter {
         }
 
         mod with_buffer_big_enough_for_largest_line {
-            use crate::file::log::iter::reflog;
-            use crate::hex_to_id;
             use gix_ref::log::Line;
 
+            use crate::{file::log::iter::reflog, hex_to_id};
+
             #[test]
             fn single_line() -> crate::Result {
                 let mut buf = [0u8; 1024];
diff --git a/gix-ref/tests/refs/file/store/mod.rs b/gix-ref/tests/refs/file/store/mod.rs
index ceb76e52d9f..7262038e7ae 100644
--- a/gix-ref/tests/refs/file/store/mod.rs
+++ b/gix-ref/tests/refs/file/store/mod.rs
@@ -1,10 +1,16 @@
-use crate::file::transaction::prepare_and_commit::{committer, create_at};
-use crate::file::EmptyCommit;
+use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
-use gix_ref::file::transaction::PackedRefs;
-use gix_ref::store::WriteReflog;
-use gix_ref::transaction::{Change, LogChange, PreviousValue, RefEdit};
-use gix_ref::Target;
+use gix_ref::{
+    file::transaction::PackedRefs,
+    store::WriteReflog,
+    transaction::{Change, LogChange, PreviousValue, RefEdit},
+    Target,
+};
+
+use crate::file::{
+    transaction::prepare_and_commit::{committer, create_at},
+    EmptyCommit,
+};
 
 mod access;
 mod find;
@@ -30,10 +36,11 @@ fn precompose_unicode_journey() -> crate::Result {
     assert!(!store_decomposed.precompose_unicode);
 
     let decomposed_ref = format!("refs/heads/{decomposed_a}");
+    let mut buf = TimeBuf::default();
     store_decomposed
         .transaction()
         .prepare(Some(create_at(&decomposed_ref)), Fail::Immediately, Fail::Immediately)?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
 
     let r = store_decomposed.iter()?.all()?.next().expect("created one ref")?;
     assert_eq!(r.name.as_bstr(), decomposed_ref, "no transformation happens by default");
@@ -79,7 +86,7 @@ fn precompose_unicode_journey() -> crate::Result {
     let edits = store_precomposed
         .transaction()
         .prepare(Some(create_at(&decomposed_ref)), Fail::Immediately, Fail::Immediately)?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
     assert_eq!(
         edits[0].name.as_bstr(),
         decomposed_ref,
@@ -118,7 +125,7 @@ fn precompose_unicode_journey() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
     assert!(
         store_precomposed.cached_packed_buffer()?.is_some(),
         "refs were written into the packed-refs file"
@@ -179,7 +186,7 @@ fn precompose_unicode_journey() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
     assert_eq!(
         edits[0].change.new_value().unwrap().try_name().unwrap().as_bstr(),
         decomposed_ref,
@@ -210,7 +217,7 @@ fn precompose_unicode_journey() -> crate::Result {
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut buf))?;
         assert_eq!(
             edits[0].name.shorten(),
             decomposed_a,
@@ -243,7 +250,7 @@ fn precompose_unicode_journey() -> crate::Result {
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut buf))?;
         assert_eq!(
             edits[0].name.shorten(),
             decomposed_u,
diff --git a/gix-ref/tests/refs/file/transaction/mod.rs b/gix-ref/tests/refs/file/transaction/mod.rs
index 926b4d597bf..efb719f6534 100644
--- a/gix-ref/tests/refs/file/transaction/mod.rs
+++ b/gix-ref/tests/refs/file/transaction/mod.rs
@@ -1,5 +1,4 @@
 pub(crate) mod prepare_and_commit {
-    use gix_date::{time::Sign, Time};
     use gix_hash::ObjectId;
     use gix_object::bstr::BString;
     use gix_ref::{
@@ -30,11 +29,7 @@ pub(crate) mod prepare_and_commit {
         gix_actor::Signature {
             name: "committer".into(),
             email: "committer@example.com".into(),
-            time: Time {
-                seconds: 1234,
-                offset: 1800,
-                sign: Sign::Plus,
-            },
+            time: gix_date::parse_header("1234 +0800").unwrap(),
         }
     }
 
diff --git a/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/collisions.rs b/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/collisions.rs
index 116a18d1b16..4bfd3ca9d60 100644
--- a/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/collisions.rs
+++ b/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/collisions.rs
@@ -1,3 +1,4 @@
+use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
 use gix_ref::{
     file::transaction::PackedRefs,
@@ -54,8 +55,9 @@ fn non_conflicting_creation_without_packed_refs_work() -> crate::Result {
         Fail::Immediately,
     )?;
 
-    t2.commit(committer().to_ref())?;
-    ongoing.commit(committer().to_ref())?;
+    let mut buf = TimeBuf::default();
+    t2.commit(committer().to_ref(&mut buf))?;
+    ongoing.commit(committer().to_ref(&mut buf))?;
 
     assert!(store.reflog_exists("refs/new")?);
     assert!(store.reflog_exists("refs/non-conflicting")?);
@@ -84,6 +86,7 @@ fn packed_refs_lock_is_mandatory_for_multiple_ongoing_transactions_even_if_one_d
 #[test]
 fn conflicting_creation_into_packed_refs() -> crate::Result {
     let (_dir, store) = empty_store()?;
+    let mut buf = TimeBuf::default();
     store
         .transaction()
         .packed_refs(PackedRefs::DeletionsAndNonSymbolicUpdatesRemoveLooseSourceReference(
@@ -98,7 +101,7 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
 
     assert_eq!(
         store.cached_packed_buffer()?.expect("created").iter()?.count(),
@@ -147,7 +150,7 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
     assert_eq!(store.iter()?.all()?.count(), 3);
 
     {
@@ -201,7 +204,7 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
     assert_eq!(
         store.loose_iter()?.count(),
         2,
@@ -215,7 +218,7 @@ fn conflicting_creation_into_packed_refs() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
 
     assert_eq!(
         store.iter()?.all()?.count(),
diff --git a/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/mod.rs b/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/mod.rs
index 0b177ec1354..510fda6ed8e 100644
--- a/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/mod.rs
+++ b/gix-ref/tests/refs/file/transaction/prepare_and_commit/create_or_update/mod.rs
@@ -1,3 +1,6 @@
+use std::error::Error;
+
+use gix_date::parse::TimeBuf;
 use gix_hash::ObjectId;
 use gix_lock::acquire::Fail;
 use gix_object::bstr::{BString, ByteSlice};
@@ -10,7 +13,6 @@ use gix_ref::{
     transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
     Target,
 };
-use std::error::Error;
 
 use crate::{
     file::{
@@ -65,6 +67,7 @@ fn reference_with_equally_named_empty_or_non_empty_directory_already_in_place_ca
             std::fs::write(head_dir.join("file.ext"), "".as_bytes())?;
         }
 
+        let mut buf = TimeBuf::default();
         let edits = store
             .transaction()
             .prepare(
@@ -80,7 +83,7 @@ fn reference_with_equally_named_empty_or_non_empty_directory_already_in_place_ca
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref());
+            .commit(committer().to_ref(&mut buf));
         if *is_empty {
             let edits = edits?;
             assert!(
@@ -166,6 +169,7 @@ fn reference_with_explicit_value_must_match_the_value_on_update() -> crate::Resu
 fn the_existing_must_match_constraint_allow_non_existing_references_to_be_created() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let expected = PreviousValue::ExistingMustMatch(Target::Object(ObjectId::empty_tree(gix_hash::Kind::Sha1)));
+    let mut buf = TimeBuf::default();
     let edits = store
         .transaction()
         .prepare(
@@ -181,7 +185,7 @@ fn the_existing_must_match_constraint_allow_non_existing_references_to_be_create
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut buf))?;
 
     assert_eq!(
         edits,
@@ -260,7 +264,7 @@ fn namespaced_updates_or_deletions_are_transparent_and_not_observable() -> crate
     let edits = store
         .transaction()
         .prepare(actual.clone(), Fail::Immediately, Fail::Immediately)?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits, actual);
     Ok(())
@@ -289,7 +293,7 @@ fn reference_with_must_exist_constraint_must_exist_already_with_any_value() -> c
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits,
@@ -335,7 +339,7 @@ fn reference_with_must_not_exist_constraint_may_exist_already_if_the_new_value_m
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits,
@@ -412,7 +416,7 @@ fn symbolic_reference_writes_reflog_if_previous_value_is_set() -> crate::Result
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
     assert_eq!(edits.len(), 1, "no split was performed");
     let head = store.find_loose(&edits[0].name)?;
     assert_eq!(head.name.as_bstr(), "refs/heads/symbolic");
@@ -504,6 +508,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
             message: "ignored".into(),
         };
         let new_head_value = Target::Symbolic(referent.try_into().unwrap());
+        let mut buf = TimeBuf::default();
         let edits = store
             .transaction()
             .prepare(
@@ -519,7 +524,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut buf))?;
         assert_eq!(
             edits,
             vec![RefEdit {
@@ -571,7 +576,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut buf))?;
 
         assert_eq!(
             edits,
@@ -669,7 +674,7 @@ fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_tho
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 1, "HEAD wasn't update");
     assert_eq!(
@@ -735,7 +740,7 @@ fn packed_refs_are_looked_up_when_checking_existing_values() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 1, "only one edit was performed in the loose refs store");
 
@@ -787,7 +792,7 @@ fn packed_refs_creation_with_packed_refs_mode_prune_removes_original_loose_refs(
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits.len(),
@@ -840,7 +845,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
         .transaction()
         .packed_refs(PackedRefs::DeletionsAndNonSymbolicUpdates(Box::new(EmptyCommit)))
         .prepare(edits, Fail::Immediately, Fail::Immediately)?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
     assert_eq!(
             edits.len(),
             2,
@@ -896,7 +901,7 @@ fn packed_refs_deletion_in_deletions_and_updates_mode() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 1, "only one edit was performed in the packed refs store");
 
diff --git a/gix-ref/tests/refs/file/transaction/prepare_and_commit/delete.rs b/gix-ref/tests/refs/file/transaction/prepare_and_commit/delete.rs
index ed28d0333dd..ca1a28fcae7 100644
--- a/gix-ref/tests/refs/file/transaction/prepare_and_commit/delete.rs
+++ b/gix-ref/tests/refs/file/transaction/prepare_and_commit/delete.rs
@@ -1,3 +1,4 @@
+use gix_date::parse::TimeBuf;
 use gix_lock::acquire::Fail;
 use gix_ref::{
     file::ReferenceExt,
@@ -30,7 +31,7 @@ fn delete_a_ref_which_is_gone_succeeds() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
     assert_eq!(edits.len(), 1);
     Ok(())
 }
@@ -81,7 +82,7 @@ fn delete_ref_and_reflog_on_symbolic_no_deref() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits,
@@ -157,7 +158,7 @@ fn delete_reflog_only_of_symbolic_no_deref() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 1);
     let head: Reference = store.find_loose("HEAD")?.into();
@@ -192,7 +193,7 @@ fn delete_reflog_only_of_symbolic_with_deref() -> crate::Result {
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 2);
     let head: Reference = store.find_loose("HEAD")?.into();
@@ -257,7 +258,7 @@ fn non_existing_can_be_deleted_with_the_may_exist_match_constraint() -> crate::R
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits,
@@ -294,7 +295,7 @@ fn delete_broken_ref_that_may_not_exist_works_even_in_deref_mode() -> crate::Res
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert!(store.try_find_loose("HEAD")?.is_none(), "the ref was deleted");
     assert_eq!(
@@ -336,7 +337,7 @@ fn store_write_mode_has_no_effect_and_reflogs_are_always_deleted() -> crate::Res
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut TimeBuf::default()))?;
         assert_eq!(edits.len(), 1);
         assert!(!store.find_loose("HEAD")?.log_exists(&store), "log was deleted");
         assert!(store.open_packed_buffer()?.is_none(), "there still is no pack");
@@ -372,7 +373,7 @@ fn packed_refs_are_consulted_when_determining_previous_value_of_ref_to_be_delete
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(edits.len(), 1, "an edit was performed in the packed refs store");
     let packed = store.open_packed_buffer()?.expect("packed ref present");
@@ -406,7 +407,7 @@ fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_
             Fail::Immediately,
             Fail::Immediately,
         )?
-        .commit(committer().to_ref())?;
+        .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
     assert_eq!(
         edits.len(),
@@ -445,7 +446,7 @@ fn all_contained_references_deletes_the_packed_ref_file_too() -> crate::Result {
                 Fail::Immediately,
                 Fail::Immediately,
             )?
-            .commit(committer().to_ref())?;
+            .commit(committer().to_ref(&mut TimeBuf::default()))?;
 
         assert!(!store.packed_refs_path().is_file(), "packed-refs was entirely removed");
 
diff --git a/gix-ref/tests/refs/file/worktree.rs b/gix-ref/tests/refs/file/worktree.rs
index de8cc54f777..d7b61ccf992 100644
--- a/gix-ref/tests/refs/file/worktree.rs
+++ b/gix-ref/tests/refs/file/worktree.rs
@@ -189,6 +189,7 @@ mod read_only {
 }
 
 mod writable {
+    use gix_date::parse::TimeBuf;
     use gix_lock::acquire::Fail;
     use gix_ref::{
         file::{transaction::PackedRefs, Store},
@@ -259,7 +260,7 @@ mod writable {
                     Fail::Immediately,
                     Fail::Immediately,
                 )?
-                .commit(committer().to_ref())
+                .commit(committer().to_ref(&mut TimeBuf::default()))
                 .expect("successful commit as even similar resolved names live in different base locations");
 
             assert_eq!(
@@ -539,7 +540,7 @@ mod writable {
                     Fail::Immediately,
                     Fail::Immediately,
                 )?
-                .commit(committer().to_ref())
+                .commit(committer().to_ref(&mut TimeBuf::default()))
                 .expect("successful commit as even similar resolved names live in different base locations");
 
             assert_eq!(
diff --git a/gix-refspec/src/match_group/types.rs b/gix-refspec/src/match_group/types.rs
index fc6792405cc..2b39f589ee8 100644
--- a/gix-refspec/src/match_group/types.rs
+++ b/gix-refspec/src/match_group/types.rs
@@ -14,8 +14,7 @@ pub struct MatchGroup<'a> {
 
 ///
 pub mod match_lhs {
-    use crate::match_group::Mapping;
-    use crate::MatchGroup;
+    use crate::{match_group::Mapping, MatchGroup};
 
     /// The outcome of any matching operation of a [`MatchGroup`].
     ///
@@ -31,8 +30,7 @@ pub mod match_lhs {
 
 ///
 pub mod match_rhs {
-    use crate::match_group::Mapping;
-    use crate::MatchGroup;
+    use crate::{match_group::Mapping, MatchGroup};
 
     /// The outcome of any matching operation of a [`MatchGroup`].
     ///
diff --git a/gix-revision/src/merge_base/function.rs b/gix-revision/src/merge_base/function.rs
index 7d59606c492..b84805b869c 100644
--- a/gix-revision/src/merge_base/function.rs
+++ b/gix-revision/src/merge_base/function.rs
@@ -1,8 +1,10 @@
-use super::Error;
-use crate::{merge_base::Flags, Graph, PriorityQueue};
+use std::cmp::Ordering;
+
 use gix_hash::ObjectId;
 use gix_revwalk::graph;
-use std::cmp::Ordering;
+
+use super::Error;
+use crate::{merge_base::Flags, Graph, PriorityQueue};
 
 /// Given a commit at `first` id, traverse the commit `graph` and return all possible merge-base between it and `others`,
 /// sorted from best to worst. Returns `None` if there is no merge-base as `first` and `others` don't share history.
diff --git a/gix-revision/src/merge_base/mod.rs b/gix-revision/src/merge_base/mod.rs
index d6e00e49915..b07e39691d5 100644
--- a/gix-revision/src/merge_base/mod.rs
+++ b/gix-revision/src/merge_base/mod.rs
@@ -25,10 +25,11 @@ pub enum Error {
 pub(crate) mod function;
 
 mod octopus {
-    use crate::merge_base::{Error, Flags};
     use gix_hash::ObjectId;
     use gix_revwalk::{graph, Graph};
 
+    use crate::merge_base::{Error, Flags};
+
     /// Given a commit at `first` id, traverse the commit `graph` and return *the best common ancestor* between it and `others`,
     /// sorted from best to worst. Returns `None` if there is no common merge-base as `first` and `others` don't *all* share history.
     /// If `others` is empty, `Some(first)` is returned.
diff --git a/gix-revision/tests/revision/merge_base/mod.rs b/gix-revision/tests/revision/merge_base/mod.rs
index 565c6298447..298b84008de 100644
--- a/gix-revision/tests/revision/merge_base/mod.rs
+++ b/gix-revision/tests/revision/merge_base/mod.rs
@@ -105,10 +105,13 @@ mod octopus {
 }
 
 mod baseline {
+    use std::{
+        ffi::OsStr,
+        path::{Path, PathBuf},
+    };
+
     use bstr::ByteSlice;
     use gix_hash::ObjectId;
-    use std::ffi::OsStr;
-    use std::path::{Path, PathBuf};
 
     /// The expectation as produced by Git itself
     #[derive(Debug)]
diff --git a/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs b/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
index 4a3fc214e85..245f9411604 100644
--- a/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
+++ b/gix-revision/tests/revision/spec/parse/navigate/caret_symbol.rs
@@ -1,6 +1,7 @@
-use crate::spec::parse::{parse, try_parse, PeelToOwned as PeelTo};
 use gix_revision::{spec, spec::parse::delegate::Traversal};
 
+use crate::spec::parse::{parse, try_parse, PeelToOwned as PeelTo};
+
 #[test]
 fn single_is_first_parent() {
     let rec = parse("@^");
diff --git a/gix-revwalk/src/graph/commit.rs b/gix-revwalk/src/graph/commit.rs
index 874585a1253..196a989864b 100644
--- a/gix-revwalk/src/graph/commit.rs
+++ b/gix-revwalk/src/graph/commit.rs
@@ -20,7 +20,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
     /// Note that this can only fail if the commit is backed by the object database *and* parsing fails.
     pub fn committer_timestamp(&self) -> Result<SecondsSinceUnixEpoch, gix_object::decode::Error> {
         Ok(match &self.backing {
-            Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf).committer()?.time.seconds,
+            Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf).committer()?.seconds(),
             Either::Right((cache, pos)) => cache.commit_at(*pos).committer_timestamp() as SecondsSinceUnixEpoch, // a cast as we cannot represent the error and trying seems overkill
         })
     }
@@ -38,10 +38,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
         &self,
     ) -> Result<(Option<Generation>, SecondsSinceUnixEpoch), gix_object::decode::Error> {
         Ok(match &self.backing {
-            Either::Left(buf) => (
-                None,
-                gix_object::CommitRefIter::from_bytes(buf).committer()?.time.seconds,
-            ),
+            Either::Left(buf) => (None, gix_object::CommitRefIter::from_bytes(buf).committer()?.seconds()),
             Either::Right((cache, pos)) => {
                 let commit = cache.commit_at(*pos);
                 (
@@ -69,7 +66,7 @@ impl<'graph, 'cache> LazyCommit<'graph, 'cache> {
                         Token::Parent { id } => parents.push(id),
                         Token::Author { .. } => {}
                         Token::Committer { signature } => {
-                            timestamp = Some(signature.time.seconds);
+                            timestamp = Some(signature.seconds());
                             break;
                         }
                         _ => {
diff --git a/gix-status/src/index_as_worktree/function.rs b/gix-status/src/index_as_worktree/function.rs
index 57981937ee9..72e58e8457a 100644
--- a/gix-status/src/index_as_worktree/function.rs
+++ b/gix-status/src/index_as_worktree/function.rs
@@ -11,13 +11,12 @@ use gix_features::parallel::{in_parallel_if, Reduce};
 use gix_filter::pipeline::convert::ToGitOutcome;
 use gix_object::FindExt;
 
-use crate::index_as_worktree::Context;
 use crate::{
     index_as_worktree::{
         traits,
         traits::{read_data::Stream, CompareBlobs, SubmoduleStatus},
         types::{Error, Options},
-        Change, Conflict, EntryStatus, Outcome, VisitEntry,
+        Change, Conflict, Context, EntryStatus, Outcome, VisitEntry,
     },
     is_dir_to_mode, AtomicU64, SymlinkCheck,
 };
@@ -575,7 +574,7 @@ where
                     },
                     &mut |buf| Ok(self.objects.find_blob(self.id, buf).map(|_| Some(()))?),
                 )
-                .map_err(|err| Error::Io(io::Error::new(io::ErrorKind::Other, err).into()))?;
+                .map_err(|err| Error::Io(io::Error::other(err).into()))?;
             let len = match out {
                 ToGitOutcome::Unchanged(_) => Some(self.file_len),
                 ToGitOutcome::Process(_) | ToGitOutcome::Buffer(_) => None,
diff --git a/gix-status/src/index_as_worktree/types.rs b/gix-status/src/index_as_worktree/types.rs
index c4ad3d16cb1..f9b4360e351 100644
--- a/gix-status/src/index_as_worktree/types.rs
+++ b/gix-status/src/index_as_worktree/types.rs
@@ -1,6 +1,7 @@
-use bstr::{BStr, BString};
 use std::sync::atomic::AtomicBool;
 
+use bstr::{BStr, BString};
+
 /// The error returned by [index_as_worktree()`](crate::index_as_worktree()).
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-status/src/index_as_worktree_with_renames/mod.rs b/gix-status/src/index_as_worktree_with_renames/mod.rs
index 4eaa8f09014..d592a7f86a9 100644
--- a/gix-status/src/index_as_worktree_with_renames/mod.rs
+++ b/gix-status/src/index_as_worktree_with_renames/mod.rs
@@ -6,14 +6,19 @@ mod recorder;
 pub use recorder::Recorder;
 
 pub(super) mod function {
-    use crate::index_as_worktree::traits::{CompareBlobs, SubmoduleStatus};
-    use crate::index_as_worktree_with_renames::function::rewrite::ModificationOrDirwalkEntry;
-    use crate::index_as_worktree_with_renames::{Context, Entry, Error, Options, Outcome, RewriteSource, VisitEntry};
-    use crate::is_dir_to_mode;
+    use std::{borrow::Cow, path::Path};
+
     use bstr::ByteSlice;
     use gix_worktree::stack::State;
-    use std::borrow::Cow;
-    use std::path::Path;
+
+    use crate::{
+        index_as_worktree::traits::{CompareBlobs, SubmoduleStatus},
+        index_as_worktree_with_renames::{
+            function::rewrite::ModificationOrDirwalkEntry, Context, Entry, Error, Options, Outcome, RewriteSource,
+            VisitEntry,
+        },
+        is_dir_to_mode,
+    };
 
     /// Similar to [`index_as_worktree(…)`](crate::index_as_worktree()), except that it will automatically
     /// track renames if enabled, while additionally providing information about untracked files
@@ -340,11 +345,14 @@ pub(super) mod function {
     }
 
     mod tracked_modifications {
-        use crate::index_as_worktree::{EntryStatus, Record};
-        use crate::index_as_worktree_with_renames::function::Event;
         use bstr::BStr;
         use gix_index::Entry;
 
+        use crate::{
+            index_as_worktree::{EntryStatus, Record},
+            index_as_worktree_with_renames::function::Event,
+        };
+
         pub(super) struct Delegate<'index, T, U> {
             pub(super) tx: std::sync::mpsc::Sender<Event<'index, T, U>>,
         }
@@ -374,12 +382,12 @@ pub(super) mod function {
     }
 
     mod dirwalk {
-        use super::Event;
-        use gix_dir::entry::Status;
-        use gix_dir::walk::Action;
-        use gix_dir::EntryRef;
         use std::sync::atomic::{AtomicBool, Ordering};
 
+        use gix_dir::{entry::Status, walk::Action, EntryRef};
+
+        use super::Event;
+
         pub(super) struct Delegate<'index, 'a, T, U> {
             pub(super) tx: std::sync::mpsc::Sender<Event<'index, T, U>>,
             pub(super) should_interrupt: &'a AtomicBool,
@@ -403,17 +411,19 @@ pub(super) mod function {
     }
 
     mod rewrite {
-        use crate::index_as_worktree::{Change, EntryStatus};
-        use crate::index_as_worktree_with_renames::{Entry, Error};
+        use std::{io::Read, path::Path};
+
         use bstr::BStr;
-        use gix_diff::rewrites::tracker::ChangeKind;
-        use gix_diff::tree::visit::Relation;
+        use gix_diff::{rewrites::tracker::ChangeKind, tree::visit::Relation};
         use gix_dir::entry::Kind;
         use gix_filter::pipeline::convert::ToGitOutcome;
         use gix_hash::oid;
         use gix_object::tree::EntryMode;
-        use std::io::Read;
-        use std::path::Path;
+
+        use crate::{
+            index_as_worktree::{Change, EntryStatus},
+            index_as_worktree_with_renames::{Entry, Error},
+        };
 
         #[derive(Clone)]
         pub enum ModificationOrDirwalkEntry<'index, T, U>
diff --git a/gix-status/src/index_as_worktree_with_renames/types.rs b/gix-status/src/index_as_worktree_with_renames/types.rs
index a6fff8980bd..e3dd9d4efe0 100644
--- a/gix-status/src/index_as_worktree_with_renames/types.rs
+++ b/gix-status/src/index_as_worktree_with_renames/types.rs
@@ -1,7 +1,9 @@
-use crate::index_as_worktree::{Change, EntryStatus};
-use bstr::{BStr, ByteSlice};
 use std::sync::atomic::AtomicBool;
 
+use bstr::{BStr, ByteSlice};
+
+use crate::index_as_worktree::{Change, EntryStatus};
+
 /// The error returned by [index_as_worktree_with_renames()`](crate::index_as_worktree_with_renames()).
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-status/src/stack.rs b/gix-status/src/stack.rs
index 75eabf66c43..3051082a729 100644
--- a/gix-status/src/stack.rs
+++ b/gix-status/src/stack.rs
@@ -1,9 +1,12 @@
-use crate::SymlinkCheck;
+use std::{
+    borrow::Cow,
+    path::{Path, PathBuf},
+};
+
 use bstr::BStr;
-use gix_fs::stack::ToNormalPathComponents;
-use gix_fs::Stack;
-use std::borrow::Cow;
-use std::path::{Path, PathBuf};
+use gix_fs::{stack::ToNormalPathComponents, Stack};
+
+use crate::SymlinkCheck;
 
 impl SymlinkCheck {
     /// Create a new stack that starts operating at `root`.
@@ -66,10 +69,7 @@ impl gix_fs::stack::Delegate for Delegate {
             }
 
             if stack.current().symlink_metadata()?.is_symlink() {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
-                    "Cannot step through symlink to perform an lstat",
-                ));
+                return Err(std::io::Error::other("Cannot step through symlink to perform an lstat"));
             }
             Ok(())
         }
diff --git a/gix-status/tests/status/index_as_worktree.rs b/gix-status/tests/status/index_as_worktree.rs
index 9d70cfefa87..a5f512f2b5b 100644
--- a/gix-status/tests/status/index_as_worktree.rs
+++ b/gix-status/tests/status/index_as_worktree.rs
@@ -8,12 +8,12 @@ use filetime::{set_file_mtime, FileTime};
 use gix_filter::eol::AutoCrlf;
 use gix_index as index;
 use gix_index::{entry, Entry};
-use gix_status::index_as_worktree::Context;
 use gix_status::{
     index_as_worktree,
     index_as_worktree::{
         traits::{CompareBlobs, FastEq, ReadData, SubmoduleStatus},
-        Change as WorktreeChange, Conflict, EntryStatus as WorktreeEntryStatus, Options, Outcome, Record, Recorder,
+        Change as WorktreeChange, Conflict, Context, EntryStatus as WorktreeEntryStatus, Options, Outcome, Record,
+        Recorder,
     },
 };
 
diff --git a/gix-status/tests/status/index_as_worktree_with_renames.rs b/gix-status/tests/status/index_as_worktree_with_renames.rs
index 468cbf4322b..7a8a7e8aa51 100644
--- a/gix-status/tests/status/index_as_worktree_with_renames.rs
+++ b/gix-status/tests/status/index_as_worktree_with_renames.rs
@@ -1,16 +1,15 @@
-use crate::fixture_path;
 use bstr::ByteSlice;
-use gix_diff::blob::pipeline::WorktreeRoots;
-use gix_diff::rewrites::CopySource;
+use gix_diff::{blob::pipeline::WorktreeRoots, rewrites::CopySource};
 use gix_index::entry;
-use gix_status::index_as_worktree::traits::FastEq;
-use gix_status::index_as_worktree::{Change, EntryStatus};
-use gix_status::index_as_worktree_with_renames;
-use gix_status::index_as_worktree_with_renames::{
-    Context, DirwalkContext, Entry, Options, Outcome, Recorder, Sorting, Summary,
+use gix_status::{
+    index_as_worktree::{traits::FastEq, Change, EntryStatus},
+    index_as_worktree_with_renames,
+    index_as_worktree_with_renames::{Context, DirwalkContext, Entry, Options, Outcome, Recorder, Sorting, Summary},
 };
 use pretty_assertions::assert_eq;
 
+use crate::fixture_path;
+
 #[test]
 fn changed_and_untracked_and_renamed() {
     let expectations_with_dirwalk = [
diff --git a/gix-submodule/src/access.rs b/gix-submodule/src/access.rs
index deba9a14007..2d52705c2c7 100644
--- a/gix-submodule/src/access.rs
+++ b/gix-submodule/src/access.rs
@@ -181,7 +181,7 @@ impl File {
                 .sections_by_name("submodule")
                 .into_iter()
                 .flatten()
-                .any(|s| (s.header().subsection_name() == Some(name) && s.meta() as *const _ != ours as *const _));
+                .any(|s| (s.header().subsection_name() == Some(name) && !std::ptr::eq(s.meta(), ours)));
             if !has_value_from_foreign_section {
                 return Err(config::update::Error::CommandForbiddenInModulesConfiguration {
                     submodule: name.to_owned(),
diff --git a/gix-transport/src/client/blocking_io/ssh/program_kind.rs b/gix-transport/src/client/blocking_io/ssh/program_kind.rs
index 0bffb85f4e1..194314dffe2 100644
--- a/gix-transport/src/client/blocking_io/ssh/program_kind.rs
+++ b/gix-transport/src/client/blocking_io/ssh/program_kind.rs
@@ -1,7 +1,6 @@
 use std::{ffi::OsStr, io::ErrorKind};
 
 use bstr::{BString, ByteSlice, ByteVec};
-
 use gix_url::ArgumentSafety::*;
 
 use crate::{
diff --git a/gix-traverse/src/commit/mod.rs b/gix-traverse/src/commit/mod.rs
index 1c19a13602a..35bca8f2b6a 100644
--- a/gix-traverse/src/commit/mod.rs
+++ b/gix-traverse/src/commit/mod.rs
@@ -3,8 +3,7 @@
 //! Use [`Simple`] for fast walks that maintain minimal state, or [`Topo`] for a more elaborate traversal.
 use gix_hash::ObjectId;
 use gix_object::FindExt;
-use gix_revwalk::graph::IdMap;
-use gix_revwalk::PriorityQueue;
+use gix_revwalk::{graph::IdMap, PriorityQueue};
 use smallvec::SmallVec;
 
 /// A fast iterator over the ancestors of one or more starting commits.
diff --git a/gix-traverse/src/commit/simple.rs b/gix-traverse/src/commit/simple.rs
index 5bb3c2cd0ec..f5047bfd985 100644
--- a/gix-traverse/src/commit/simple.rs
+++ b/gix-traverse/src/commit/simple.rs
@@ -1,9 +1,9 @@
+use std::{cmp::Reverse, collections::VecDeque};
+
 use gix_date::SecondsSinceUnixEpoch;
 use gix_hash::ObjectId;
 use gix_hashtable::HashSet;
 use smallvec::SmallVec;
-use std::cmp::Reverse;
-use std::collections::VecDeque;
 
 #[derive(Default, Debug, Copy, Clone)]
 /// The order with which to prioritize the search.
@@ -92,10 +92,11 @@ pub(super) struct State {
 
 ///
 mod init {
+    use std::cmp::Reverse;
+
     use gix_date::SecondsSinceUnixEpoch;
     use gix_hash::{oid, ObjectId};
     use gix_object::{CommitRefIter, FindExt};
-    use std::cmp::Reverse;
     use Err as Oldest;
     use Ok as Newest;
 
@@ -150,7 +151,7 @@ mod init {
                     let state = &mut self.state;
                     for commit_id in state.next.drain(..) {
                         let commit_iter = self.objects.find_commit_iter(&commit_id, &mut state.buf)?;
-                        let time = commit_iter.committer()?.time.seconds;
+                        let time = commit_iter.committer()?.seconds();
                         let key = to_queue_key(time, order);
                         match (cutoff_time, order) {
                             (Some(cutoff_time), _) if time >= cutoff_time => {
@@ -351,7 +352,7 @@ mod init {
 
                                 let parent = self.objects.find_commit_iter(id.as_ref(), &mut state.parents_buf).ok();
                                 let parent_commit_time = parent
-                                    .and_then(|parent| parent.committer().ok().map(|committer| committer.time.seconds))
+                                    .and_then(|parent| parent.committer().ok().map(|committer| committer.seconds()))
                                     .unwrap_or_default();
 
                                 let time = to_queue_key(parent_commit_time, order);
diff --git a/gix-traverse/src/commit/topo/init.rs b/gix-traverse/src/commit/topo/init.rs
index dfbf357fb62..240b24043ce 100644
--- a/gix-traverse/src/commit/topo/init.rs
+++ b/gix-traverse/src/commit/topo/init.rs
@@ -1,9 +1,11 @@
-use crate::commit::topo::iter::gen_and_commit_time;
-use crate::commit::topo::{Error, Sorting, WalkFlags};
-use crate::commit::{find, Info, Parents, Topo};
 use gix_hash::{oid, ObjectId};
-use gix_revwalk::graph::IdMap;
-use gix_revwalk::PriorityQueue;
+use gix_revwalk::{graph::IdMap, PriorityQueue};
+
+use crate::commit::{
+    find,
+    topo::{iter::gen_and_commit_time, Error, Sorting, WalkFlags},
+    Info, Parents, Topo,
+};
 
 /// Builder for [`Topo`].
 pub struct Builder<Find, Predicate> {
diff --git a/gix-traverse/src/commit/topo/iter.rs b/gix-traverse/src/commit/topo/iter.rs
index 547fa4e4359..ca1d883f426 100644
--- a/gix-traverse/src/commit/topo/iter.rs
+++ b/gix-traverse/src/commit/topo/iter.rs
@@ -1,9 +1,13 @@
-use crate::commit::topo::{Error, Sorting, WalkFlags};
-use crate::commit::{find, Either, Info, Parents, Topo};
 use gix_hash::{oid, ObjectId};
 use gix_revwalk::PriorityQueue;
 use smallvec::SmallVec;
 
+use crate::commit::{
+    find,
+    topo::{Error, Sorting, WalkFlags},
+    Either, Info, Parents, Topo,
+};
+
 pub(in crate::commit) type GenAndCommitTime = (u32, i64);
 
 // Git's priority queue works as a LIFO stack if no compare function is set,
@@ -304,7 +308,7 @@ pub(super) fn gen_and_commit_time(c: Either<'_, '_>) -> Result<GenAndCommitTime,
                     Ok(T::Parent { .. }) => continue,
                     Ok(T::Author { .. }) => continue,
                     Ok(T::Committer { signature }) => {
-                        commit_time = signature.time.seconds;
+                        commit_time = signature.seconds();
                         break;
                     }
                     Ok(_unused_token) => break,
diff --git a/gix-traverse/src/tree/depthfirst.rs b/gix-traverse/src/tree/depthfirst.rs
index 5b0c9eab79c..012b19b830c 100644
--- a/gix-traverse/src/tree/depthfirst.rs
+++ b/gix-traverse/src/tree/depthfirst.rs
@@ -25,12 +25,13 @@ impl State {
 }
 
 pub(super) mod function {
-    use super::{Error, State};
-    use crate::tree::visit::Action;
-    use crate::tree::Visit;
+    use std::borrow::BorrowMut;
+
     use gix_hash::ObjectId;
     use gix_object::{FindExt, TreeRefIter};
-    use std::borrow::BorrowMut;
+
+    use super::{Error, State};
+    use crate::tree::{visit::Action, Visit};
 
     /// A depth-first traversal of the `root` tree, that preserves the natural order of a tree while immediately descending
     /// into sub-trees.
diff --git a/gix-traverse/tests/traverse/commit/simple.rs b/gix-traverse/tests/traverse/commit/simple.rs
index de02555b58b..0b5bc02b7db 100644
--- a/gix-traverse/tests/traverse/commit/simple.rs
+++ b/gix-traverse/tests/traverse/commit/simple.rs
@@ -229,9 +229,12 @@ mod different_date {
 
 /// Same dates are somewhat special as they show how sorting-details on priority queues affects ordering
 mod same_date {
+    use gix_traverse::commit::{
+        simple::{CommitTimeOrder, Sorting},
+        Parents,
+    };
+
     use crate::{commit::simple::TraversalAssertion, hex_to_id};
-    use gix_traverse::commit::simple::CommitTimeOrder;
-    use gix_traverse::commit::{simple::Sorting, Parents};
 
     #[test]
     fn c4_breadth_first() -> crate::Result {
@@ -395,9 +398,12 @@ mod same_date {
 
 /// Some dates adjusted to be a year apart, but still 'c1' and 'c2' with the same date.
 mod adjusted_dates {
+    use gix_traverse::commit::{
+        simple::{CommitTimeOrder, Sorting},
+        Parents, Simple,
+    };
+
     use crate::{commit::simple::TraversalAssertion, hex_to_id};
-    use gix_traverse::commit::simple::CommitTimeOrder;
-    use gix_traverse::commit::{simple::Sorting, Parents, Simple};
 
     #[test]
     fn head_breadth_first() -> crate::Result {
diff --git a/gix-traverse/tests/traverse/commit/topo.rs b/gix-traverse/tests/traverse/commit/topo.rs
index 4486a53023f..0b9ffe6cfb6 100644
--- a/gix-traverse/tests/traverse/commit/topo.rs
+++ b/gix-traverse/tests/traverse/commit/topo.rs
@@ -1,7 +1,8 @@
+use std::path::PathBuf;
+
 use gix_hash::{oid, ObjectId};
 use gix_object::bstr::ByteSlice;
 use gix_traverse::commit::{topo, Parents};
-use std::path::PathBuf;
 
 use crate::hex_to_id;
 
@@ -127,7 +128,6 @@ mod basic {
     use gix_traverse::commit::topo;
 
     use super::TraversalAssertion;
-
     use crate::hex_to_id;
 
     #[test]
diff --git a/gix-traverse/tests/traverse/tree.rs b/gix-traverse/tests/traverse/tree.rs
index 048ade4a205..003ecbf3b32 100644
--- a/gix-traverse/tests/traverse/tree.rs
+++ b/gix-traverse/tests/traverse/tree.rs
@@ -9,11 +9,13 @@ fn named_db(name: &str) -> crate::Result<gix_odb::Handle> {
 }
 
 mod depthfirst {
-    use crate::hex_to_id;
-    use crate::tree::{db, named_db};
     use gix_object::FindExt;
-    use gix_traverse::tree;
-    use gix_traverse::tree::recorder::Location;
+    use gix_traverse::{tree, tree::recorder::Location};
+
+    use crate::{
+        hex_to_id,
+        tree::{db, named_db},
+    };
 
     #[test]
     fn full_path_and_filename() -> crate::Result {
@@ -231,12 +233,11 @@ mod depthfirst {
 }
 
 mod breadthfirst {
-    use crate::hex_to_id;
-    use crate::tree::db;
     use gix_object::bstr::BString;
     use gix_odb::pack::FindExt;
-    use gix_traverse::tree;
-    use gix_traverse::tree::recorder::Location;
+    use gix_traverse::{tree, tree::recorder::Location};
+
+    use crate::{hex_to_id, tree::db};
 
     #[test]
     fn full_path() -> crate::Result {
diff --git a/gix-url/src/parse.rs b/gix-url/src/parse.rs
index f4cf870571c..d35c0c11493 100644
--- a/gix-url/src/parse.rs
+++ b/gix-url/src/parse.rs
@@ -1,9 +1,10 @@
 use std::convert::Infallible;
 
-use crate::Scheme;
 use bstr::{BStr, BString, ByteSlice};
 use percent_encoding::percent_decode_str;
 
+use crate::Scheme;
+
 /// The error returned by [parse()](crate::parse()).
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
diff --git a/gix-utils/src/str.rs b/gix-utils/src/str.rs
index a8adb141e6e..335a32bf4fa 100644
--- a/gix-utils/src/str.rs
+++ b/gix-utils/src/str.rs
@@ -1,6 +1,4 @@
-use std::borrow::Cow;
-use std::ffi::OsStr;
-use std::path::Path;
+use std::{borrow::Cow, ffi::OsStr, path::Path};
 
 /// Assure that `s` is precomposed, i.e. `ä` is a single code-point, and not two i.e. `a` and `<umlaut>`.
 ///
diff --git a/gix-validate/tests/path/mod.rs b/gix-validate/tests/path/mod.rs
index 4c53601a932..b7eb8cad171 100644
--- a/gix-validate/tests/path/mod.rs
+++ b/gix-validate/tests/path/mod.rs
@@ -23,10 +23,10 @@ mod component {
     };
 
     mod valid {
-        use crate::path::component::{ALL_OPTS, NO_OPTS};
         use bstr::ByteSlice;
-        use gix_validate::path::component;
-        use gix_validate::path::component::Mode::Symlink;
+        use gix_validate::path::{component, component::Mode::Symlink};
+
+        use crate::path::component::{ALL_OPTS, NO_OPTS};
         macro_rules! mktest {
             ($name:ident, $input:expr) => {
                 mktest!($name, $input, ALL_OPTS);
@@ -103,10 +103,10 @@ mod component {
     }
 
     mod invalid {
-        use crate::path::component::{ALL_OPTS, NO_OPTS};
         use bstr::ByteSlice;
-        use gix_validate::path::component::Error;
-        use gix_validate::path::component::Mode::Symlink;
+        use gix_validate::path::component::{Error, Mode::Symlink};
+
+        use crate::path::component::{ALL_OPTS, NO_OPTS};
 
         macro_rules! mktest {
             ($name:ident, $input:expr, $expected:pat) => {
diff --git a/gix-worktree-state/tests/state/checkout.rs b/gix-worktree-state/tests/state/checkout.rs
index c45c19fb042..764b52020d3 100644
--- a/gix-worktree-state/tests/state/checkout.rs
+++ b/gix-worktree-state/tests/state/checkout.rs
@@ -30,7 +30,7 @@ static DRIVER: Lazy<PathBuf> = Lazy::new(|| {
         .join("debug")
         .join("examples")
         .join(if cfg!(windows) { "arrow.exe" } else { "arrow" });
-    assert!(path.is_file(), "Expecting driver to be located at {path:?}");
+    assert!(path.is_file(), "Expecting driver to be located at {}", path.display());
     path
 });
 
diff --git a/gix-worktree-stream/src/protocol.rs b/gix-worktree-stream/src/protocol.rs
index 0da161f397b..49074f22df0 100644
--- a/gix-worktree-stream/src/protocol.rs
+++ b/gix-worktree-stream/src/protocol.rs
@@ -1,7 +1,9 @@
-use crate::utils;
-use gix_object::bstr::{BStr, BString};
 use std::io::{self, ErrorKind, Read, Write};
 
+use gix_object::bstr::{BStr, BString};
+
+use crate::utils;
+
 // Format: [usize-LE][usize-LE][byte][byte][hash][relative_path_bytes][object_stream]
 // Note that stream_len can be usize::MAX to indicate the stream size is unknown
 pub(crate) fn read_entry_info(
diff --git a/gix-worktree-stream/tests/stream.rs b/gix-worktree-stream/tests/stream.rs
index 46551193ff7..15858750aed 100644
--- a/gix-worktree-stream/tests/stream.rs
+++ b/gix-worktree-stream/tests/stream.rs
@@ -295,7 +295,7 @@ mod from_tree {
             .join("debug")
             .join("examples")
             .join(if cfg!(windows) { "arrow.exe" } else { "arrow" });
-        assert!(path.is_file(), "Expecting driver to be located at {path:?}");
+        assert!(path.is_file(), "Expecting driver to be located at {}", path.display());
         path
     });
 
diff --git a/gix-worktree/src/stack/delegate.rs b/gix-worktree/src/stack/delegate.rs
index 01a84611056..c366b2932a8 100644
--- a/gix-worktree/src/stack/delegate.rs
+++ b/gix-worktree/src/stack/delegate.rs
@@ -135,15 +135,12 @@ fn validate_last_component(
     let Some(last_component) = stack.current_relative().components().next_back() else {
         return Ok(());
     };
-    let last_component =
-        gix_path::try_into_bstr(std::borrow::Cow::Borrowed(last_component.as_os_str().as_ref())).map_err(|_err| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "Path component {last_component:?} of path \"{}\" contained invalid UTF-8 and could not be validated",
-                    stack.current_relative().display()
-                ),
-            )
+    let last_component = gix_path::try_into_bstr(std::borrow::Cow::Borrowed(last_component.as_os_str().as_ref()))
+        .map_err(|_err| {
+            std::io::Error::other(format!(
+                "Path component {last_component:?} of path \"{}\" contained invalid UTF-8 and could not be validated",
+                stack.current_relative().display()
+            ))
         })?;
 
     if let Err(err) = gix_validate::path::component(
@@ -153,7 +150,7 @@ fn validate_last_component(
         }),
         opts,
     ) {
-        return Err(std::io::Error::new(std::io::ErrorKind::Other, err));
+        return Err(std::io::Error::other(err));
     }
     Ok(())
 }
diff --git a/gix-worktree/src/stack/state/attributes.rs b/gix-worktree/src/stack/state/attributes.rs
index cf2377357e8..ef6191ef1df 100644
--- a/gix-worktree/src/stack/state/attributes.rs
+++ b/gix-worktree/src/stack/state/attributes.rs
@@ -110,7 +110,7 @@ impl Attributes {
                 if let Ok(idx) = attr_file_in_index {
                     let blob = objects
                         .find_blob(&id_mappings[idx].1, buf)
-                        .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                        .map_err(std::io::Error::other)?;
                     let attr_path = gix_path::from_bstring(attr_path_relative.into_owned());
                     self.stack.add_patterns_buffer(
                         blob.data,
@@ -149,7 +149,7 @@ impl Attributes {
                 if let Some(idx) = attr_file_in_index.ok().filter(|_| !added) {
                     let blob = objects
                         .find_blob(&id_mappings[idx].1, buf)
-                        .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                        .map_err(std::io::Error::other)?;
                     let attr_path = gix_path::from_bstring(attr_path_relative.into_owned());
                     self.stack.add_patterns_buffer(
                         blob.data,
diff --git a/gix-worktree/src/stack/state/ignore.rs b/gix-worktree/src/stack/state/ignore.rs
index bba982cd8ec..05c0f48d9f9 100644
--- a/gix-worktree/src/stack/state/ignore.rs
+++ b/gix-worktree/src/stack/state/ignore.rs
@@ -180,7 +180,7 @@ impl Ignore {
                     Ok(idx) => {
                         let ignore_blob = objects
                             .find_blob(&id_mappings[idx].1, buf)
-                            .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                            .map_err(std::io::Error::other)?;
                         let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned());
                         self.stack
                             .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new("")));
@@ -208,7 +208,7 @@ impl Ignore {
                         Ok(idx) => {
                             let ignore_blob = objects
                                 .find_blob(&id_mappings[idx].1, buf)
-                                .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+                                .map_err(std::io::Error::other)?;
                             let ignore_path = gix_path::from_bstring(ignore_path_relative.into_owned());
                             self.stack
                                 .add_patterns_buffer(ignore_blob.data, ignore_path, Some(Path::new("")));
diff --git a/gix-worktree/tests/worktree/stack/ignore.rs b/gix-worktree/tests/worktree/stack/ignore.rs
index a1ad67eb07e..03feec6c4ac 100644
--- a/gix-worktree/tests/worktree/stack/ignore.rs
+++ b/gix-worktree/tests/worktree/stack/ignore.rs
@@ -1,9 +1,11 @@
-use crate::{hex_to_id, worktree::stack::probe_case};
+use std::fs::Metadata;
+
 use bstr::{BStr, ByteSlice};
 use gix_fs::stack::ToNormalPathComponents;
 use gix_index::entry::Mode;
 use gix_worktree::{stack::state::ignore::Source, Stack};
-use std::fs::Metadata;
+
+use crate::{hex_to_id, worktree::stack::probe_case};
 
 struct IgnoreExpectations<'a> {
     lines: bstr::Lines<'a>,
diff --git a/gix/examples/clone.rs b/gix/examples/clone.rs
index 356863c784f..9f1441ed90a 100644
--- a/gix/examples/clone.rs
+++ b/gix/examples/clone.rs
@@ -26,12 +26,15 @@ fn main() -> anyhow::Result<()> {
         prepare_clone.fetch_then_checkout(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;
 
     println!(
-        "Checking out into {:?} ...",
-        prepare_checkout.repo().workdir().expect("should be there")
+        "Checking out into {} ...",
+        prepare_checkout.repo().workdir().expect("should be there").display()
     );
 
     let (repo, _) = prepare_checkout.main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;
-    println!("Repo cloned into {:?}", repo.workdir().expect("directory pre-created"));
+    println!(
+        "Repo cloned into {}",
+        repo.workdir().expect("directory pre-created").display()
+    );
 
     let remote = repo
         .find_default_remote(gix::remote::Direction::Fetch)
diff --git a/gix/examples/init-repo-and-commit.rs b/gix/examples/init-repo-and-commit.rs
index e3397bff6bd..9766e9e51e7 100644
--- a/gix/examples/init-repo-and-commit.rs
+++ b/gix/examples/init-repo-and-commit.rs
@@ -14,7 +14,7 @@ fn main() -> anyhow::Result<()> {
         .context("First argument needs to be the directory to initialize the repository in")?;
     let mut repo = gix::init_bare(git_dir)?;
 
-    println!("Repo (bare): {:?}", repo.git_dir());
+    println!("Repo (bare): {}", repo.git_dir().display());
 
     let mut tree = gix::objs::Tree::empty();
     let empty_tree_id = repo.write_object(&tree)?.detach();
diff --git a/gix/src/attribute_stack.rs b/gix/src/attribute_stack.rs
index 4f1da159672..70e99167cdc 100644
--- a/gix/src/attribute_stack.rs
+++ b/gix/src/attribute_stack.rs
@@ -1,7 +1,9 @@
-use crate::{types::AttributeStack, Repository};
-use gix_fs::stack::ToNormalPathComponents;
 use std::ops::{Deref, DerefMut};
 
+use gix_fs::stack::ToNormalPathComponents;
+
+use crate::{types::AttributeStack, Repository};
+
 /// Lifecycle
 impl<'repo> AttributeStack<'repo> {
     /// Create a new instance from a `repo` and the underlying pre-configured `stack`.
diff --git a/gix/src/clone/fetch/mod.rs b/gix/src/clone/fetch/mod.rs
index 1485871a159..65210022c2e 100644
--- a/gix/src/clone/fetch/mod.rs
+++ b/gix/src/clone/fetch/mod.rs
@@ -1,6 +1,7 @@
-use crate::bstr::BString;
-use crate::bstr::ByteSlice;
-use crate::clone::PrepareFetch;
+use crate::{
+    bstr::{BString, ByteSlice},
+    clone::PrepareFetch,
+};
 
 /// The error returned by [`PrepareFetch::fetch_only()`].
 #[derive(Debug, thiserror::Error)]
diff --git a/gix/src/commit.rs b/gix/src/commit.rs
index d9c8d635ba6..2a5af16f404 100644
--- a/gix/src/commit.rs
+++ b/gix/src/commit.rs
@@ -126,7 +126,7 @@ pub mod describe {
                         let (prio, tag_time) = match target_id {
                             Some(target_id) if peeled_id != *target_id => {
                                 let tag = repo.find_object(target_id).ok()?.try_into_tag().ok()?;
-                                (1, tag.tagger().ok()??.time.seconds)
+                                (1, tag.tagger().ok()??.seconds())
                             }
                             _ => (0, 0),
                         };
@@ -159,7 +159,7 @@ pub mod describe {
                             // TODO: we assume direct refs for tags, which is the common case, but it doesn't have to be
                             //       so rather follow symrefs till the first object and then peel tags after the first object was found.
                             let tag = r.try_id()?.object().ok()?.try_into_tag().ok()?;
-                            let tag_time = tag.tagger().ok().and_then(|s| s.map(|s| s.time.seconds)).unwrap_or(0);
+                            let tag_time = tag.tagger().ok().and_then(|s| s.map(|s| s.seconds())).unwrap_or(0);
                             let commit_id = tag.target_id().ok()?.object().ok()?.try_into_commit().ok()?.id;
                             Some((commit_id, tag_time, Cow::<BStr>::from(r.name().shorten().to_owned())))
                         })
diff --git a/gix/src/config/cache/access.rs b/gix/src/config/cache/access.rs
index df2ca193c10..aa5b59f6f1a 100644
--- a/gix/src/config/cache/access.rs
+++ b/gix/src/config/cache/access.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::result_large_err)]
+use std::{borrow::Cow, path::PathBuf, time::Duration};
+
 use gix_config::file::Metadata;
 use gix_lock::acquire::Fail;
-use std::{borrow::Cow, path::PathBuf, time::Duration};
 
 use crate::{
     config,
diff --git a/gix/src/config/cache/incubate.rs b/gix/src/config/cache/incubate.rs
index ca24f616f39..1960d196fb5 100644
--- a/gix/src/config/cache/incubate.rs
+++ b/gix/src/config/cache/incubate.rs
@@ -1,8 +1,10 @@
 #![allow(clippy::result_large_err)]
 
 use super::{util, Error};
-use crate::config::cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue};
-use crate::config::tree::{gitoxide, Core, Extensions};
+use crate::config::{
+    cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
+    tree::{gitoxide, Core, Extensions},
+};
 
 /// A utility to deal with the cyclic dependency between the ref store and the configuration. The ref-store needs the
 /// object hash kind, and the configuration needs the current branch name to resolve conditional includes with `onbranch`.
diff --git a/gix/src/config/snapshot/access.rs b/gix/src/config/snapshot/access.rs
index 6b753ab050e..91cbfc84d8b 100644
--- a/gix/src/config/snapshot/access.rs
+++ b/gix/src/config/snapshot/access.rs
@@ -1,12 +1,10 @@
 #![allow(clippy::result_large_err)]
-use std::borrow::Cow;
-use std::ffi::OsStr;
+use std::{borrow::Cow, ffi::OsStr};
 
 use gix_features::threading::OwnShared;
 
-use crate::bstr::ByteSlice;
 use crate::{
-    bstr::{BStr, BString},
+    bstr::{BStr, BString, ByteSlice},
     config::{CommitAutoRollback, Snapshot, SnapshotMut},
 };
 
diff --git a/gix/src/config/snapshot/credential_helpers.rs b/gix/src/config/snapshot/credential_helpers.rs
index 7680ccf69a8..cea7042f639 100644
--- a/gix/src/config/snapshot/credential_helpers.rs
+++ b/gix/src/config/snapshot/credential_helpers.rs
@@ -49,13 +49,17 @@ impl Snapshot<'_> {
 }
 
 pub(super) mod function {
-    use crate::bstr::{ByteSlice, ByteVec};
-    use crate::config::cache::util::ApplyLeniency;
-    use crate::config::credential_helpers::Error;
-    use crate::config::tree::gitoxide::Credentials;
-    use crate::config::tree::{credential, Core, Credential};
     use std::borrow::Cow;
 
+    use crate::{
+        bstr::{ByteSlice, ByteVec},
+        config::{
+            cache::util::ApplyLeniency,
+            credential_helpers::Error,
+            tree::{credential, gitoxide::Credentials, Core, Credential},
+        },
+    };
+
     /// Returns the configuration for all git-credential helpers from trusted configuration that apply
     /// to the given `url` along with an action preconfigured to invoke the cascade with to retrieve it.
     /// This includes `url` which may be altered to contain a user-name as configured.
diff --git a/gix/src/config/tree/keys.rs b/gix/src/config/tree/keys.rs
index 9b9f6ede1fd..c2df5a3842e 100644
--- a/gix/src/config/tree/keys.rs
+++ b/gix/src/config/tree/keys.rs
@@ -1,11 +1,12 @@
 #![allow(clippy::result_large_err)]
-use gix_config::KeyRef;
 use std::{
     borrow::Cow,
     error::Error,
     fmt::{Debug, Formatter},
 };
 
+use gix_config::KeyRef;
+
 use crate::{
     bstr::BStr,
     config,
diff --git a/gix/src/config/tree/sections/gitoxide.rs b/gix/src/config/tree/sections/gitoxide.rs
index 37c706af0e6..af24cfac66a 100644
--- a/gix/src/config/tree/sections/gitoxide.rs
+++ b/gix/src/config/tree/sections/gitoxide.rs
@@ -511,11 +511,11 @@ mod subsections {
 
     impl Commit {
         /// The `gitoxide.commit.authorDate` key.
-        pub const AUTHOR_DATE: keys::Time =
-            keys::Time::new_time("authorDate", &Gitoxide::COMMIT).with_environment_override("GIT_AUTHOR_DATE");
+        pub const AUTHOR_DATE: keys::Any =
+            keys::Any::new("authorDate", &Gitoxide::COMMIT).with_environment_override("GIT_AUTHOR_DATE");
         /// The `gitoxide.commit.committerDate` key.
-        pub const COMMITTER_DATE: keys::Time =
-            keys::Time::new_time("committerDate", &Gitoxide::COMMIT).with_environment_override("GIT_COMMITTER_DATE");
+        pub const COMMITTER_DATE: keys::Any =
+            keys::Any::new("committerDate", &Gitoxide::COMMIT).with_environment_override("GIT_COMMITTER_DATE");
     }
 
     impl Section for Commit {
diff --git a/gix/src/config/tree/sections/merge.rs b/gix/src/config/tree/sections/merge.rs
index 78852078225..6feb9281802 100644
--- a/gix/src/config/tree/sections/merge.rs
+++ b/gix/src/config/tree/sections/merge.rs
@@ -1,8 +1,9 @@
-use crate::config;
-use crate::config::tree::SubSectionRequirement;
-use crate::config::{
-    tree::{keys, Key, Merge, Section},
-    Tree,
+use crate::{
+    config,
+    config::{
+        tree::{keys, Key, Merge, Section, SubSectionRequirement},
+        Tree,
+    },
 };
 
 impl Merge {
@@ -63,10 +64,12 @@ pub type ConflictStyle = keys::Any<validate::ConflictStyle>;
 
 #[cfg(feature = "merge")]
 mod conflict_style {
-    use crate::{bstr::BStr, config, config::tree::sections::merge::ConflictStyle};
-    use gix_merge::blob::builtin_driver::text;
     use std::borrow::Cow;
 
+    use gix_merge::blob::builtin_driver::text;
+
+    use crate::{bstr::BStr, config, config::tree::sections::merge::ConflictStyle};
+
     impl ConflictStyle {
         /// Derive the diff algorithm identified by `name`, case-insensitively.
         pub fn try_into_conflict_style(
diff --git a/gix/src/config/tree/sections/status.rs b/gix/src/config/tree/sections/status.rs
index 28038325785..6daee4c4776 100644
--- a/gix/src/config/tree/sections/status.rs
+++ b/gix/src/config/tree/sections/status.rs
@@ -1,6 +1,7 @@
-use crate::config;
-use crate::config::tree::sections::Status;
-use crate::config::tree::{keys, Key, Section};
+use crate::{
+    config,
+    config::tree::{keys, sections::Status, Key, Section},
+};
 
 impl Status {
     /// The `status.showUntrackedFiles` key
diff --git a/gix/src/dirwalk/iter.rs b/gix/src/dirwalk/iter.rs
index 9bbe2449651..fc75719c77a 100644
--- a/gix/src/dirwalk/iter.rs
+++ b/gix/src/dirwalk/iter.rs
@@ -1,10 +1,11 @@
-use super::Iter;
-use crate::bstr::BString;
-use crate::util::OwnedOrStaticAtomicBool;
-use crate::worktree::IndexPersistedOrInMemory;
-use crate::{dirwalk, PathspecDetached, Repository};
 use std::path::PathBuf;
 
+use super::Iter;
+use crate::{
+    bstr::BString, dirwalk, util::OwnedOrStaticAtomicBool, worktree::IndexPersistedOrInMemory, PathspecDetached,
+    Repository,
+};
+
 /// An entry of the directory walk as returned by the [iterator](Iter).
 pub struct Item {
     /// The directory entry.
diff --git a/gix/src/dirwalk/mod.rs b/gix/src/dirwalk/mod.rs
index 83009d3f711..4bec889a3e3 100644
--- a/gix/src/dirwalk/mod.rs
+++ b/gix/src/dirwalk/mod.rs
@@ -1,7 +1,8 @@
+use std::path::PathBuf;
+
 use gix_dir::walk::{CollapsedEntriesEmissionMode, EmissionMode, ForDeletionMode};
 
 use crate::{config, AttributeStack, Pathspec};
-use std::path::PathBuf;
 
 mod options;
 
diff --git a/gix/src/dirwalk/options.rs b/gix/src/dirwalk/options.rs
index c72dc157148..8c292821719 100644
--- a/gix/src/dirwalk/options.rs
+++ b/gix/src/dirwalk/options.rs
@@ -1,6 +1,7 @@
-use crate::dirwalk::Options;
 use gix_dir::walk::{CollapsedEntriesEmissionMode, EmissionMode, ForDeletionMode};
 
+use crate::dirwalk::Options;
+
 /// Construction
 impl Options {
     pub(crate) fn from_fs_caps(caps: gix_fs::Capabilities) -> Self {
diff --git a/gix/src/filter.rs b/gix/src/filter.rs
index bc0cb8c5768..cf08b24fc2e 100644
--- a/gix/src/filter.rs
+++ b/gix/src/filter.rs
@@ -4,13 +4,13 @@ use std::borrow::Cow;
 pub use gix_filter as plumbing;
 use gix_object::Find;
 
-use crate::prelude::ObjectIdExt;
 use crate::{
     bstr::BStr,
     config::{
         cache::util::{ApplyLeniency, ApplyLeniencyDefaultValue},
         tree::Core,
     },
+    prelude::ObjectIdExt,
     Repository,
 };
 
diff --git a/gix/src/merge.rs b/gix/src/merge.rs
index 8a93121eaa4..6015e7b80ac 100644
--- a/gix/src/merge.rs
+++ b/gix/src/merge.rs
@@ -1,5 +1,4 @@
 pub use gix_merge as plumbing;
-
 pub use gix_merge::blob;
 
 ///
diff --git a/gix/src/object/commit.rs b/gix/src/object/commit.rs
index b5da82b95a4..93354143eb6 100644
--- a/gix/src/object/commit.rs
+++ b/gix/src/object/commit.rs
@@ -10,6 +10,8 @@ mod error {
         FindExistingObject(#[from] object::find::existing::Error),
         #[error("The commit could not be decoded fully or partially")]
         Decode(#[from] gix_object::decode::Error),
+        #[error("The commit date could not be parsed")]
+        ParseDate(#[from] gix_date::parse::Error),
         #[error("Expected object of type {}, but got {}", .expected, .actual)]
         ObjectKind {
             expected: gix_object::Kind,
@@ -74,7 +76,7 @@ impl<'repo> Commit<'repo> {
     ///
     /// For the time at which it was authored, refer to `.decode()?.author.time`.
     pub fn time(&self) -> Result<gix_date::Time, Error> {
-        Ok(self.committer()?.time)
+        Ok(self.committer()?.time()?)
     }
 
     /// Decode the entire commit object and return it for accessing all commit information.
diff --git a/gix/src/object/tree/diff/change.rs b/gix/src/object/tree/diff/change.rs
index 0651d8dbd11..bb81895c49e 100644
--- a/gix/src/object/tree/diff/change.rs
+++ b/gix/src/object/tree/diff/change.rs
@@ -1,8 +1,10 @@
 use super::ChangeDetached;
-use crate::bstr::{BStr, ByteSlice};
-use crate::ext::ObjectIdExt;
-use crate::object::tree::diff::Change;
-use crate::Repository;
+use crate::{
+    bstr::{BStr, ByteSlice},
+    ext::ObjectIdExt,
+    object::tree::diff::Change,
+    Repository,
+};
 
 impl Change<'_, '_, '_> {
     /// Produce a platform for performing a line-diff no matter whether the underlying [Change] is an addition, modification,
diff --git a/gix/src/object/tree/editor.rs b/gix/src/object/tree/editor.rs
index 6d8694f8ce1..d1e352b5c12 100644
--- a/gix/src/object/tree/editor.rs
+++ b/gix/src/object/tree/editor.rs
@@ -1,9 +1,12 @@
-use crate::bstr::{BStr, BString};
-use crate::prelude::ObjectIdExt;
-use crate::{Id, Repository};
 use gix_hash::ObjectId;
 use gix_object::tree::EntryKind;
 
+use crate::{
+    bstr::{BStr, BString},
+    prelude::ObjectIdExt,
+    Id, Repository,
+};
+
 ///
 pub mod init {
     /// The error returned by [`Editor::new()](crate::object::tree::Editor::new()).
diff --git a/gix/src/open/repository.rs b/gix/src/open/repository.rs
index 422f2f4f3e3..25a8af99453 100644
--- a/gix/src/open/repository.rs
+++ b/gix/src/open/repository.rs
@@ -1,4 +1,15 @@
 #![allow(clippy::result_large_err)]
+use std::{
+    borrow::Cow,
+    collections::{btree_map::Entry, BTreeMap},
+    ffi::OsStr,
+    path::PathBuf,
+};
+
+use gix_features::threading::OwnShared;
+use gix_object::bstr::ByteSlice;
+use gix_path::RelativePath;
+
 use super::{Error, Options};
 use crate::{
     bstr::BString,
@@ -10,13 +21,6 @@ use crate::{
     open::Permissions,
     ThreadSafeRepository,
 };
-use gix_features::threading::OwnShared;
-use gix_object::bstr::ByteSlice;
-use gix_path::RelativePath;
-use std::collections::btree_map::Entry;
-use std::collections::BTreeMap;
-use std::ffi::OsStr;
-use std::{borrow::Cow, path::PathBuf};
 
 #[derive(Default, Clone)]
 pub(crate) struct EnvironmentOverrides {
diff --git a/gix/src/path.rs b/gix/src/path.rs
index 9fd6d4b0169..d5cd5e510ad 100644
--- a/gix/src/path.rs
+++ b/gix/src/path.rs
@@ -6,6 +6,6 @@ pub(crate) fn install_dir() -> std::io::Result<PathBuf> {
     std::env::current_exe().and_then(|exe| {
         exe.parent()
             .map(ToOwned::to_owned)
-            .ok_or_else(|| std::io::Error::new(std::io::ErrorKind::Other, "no parent for current executable"))
+            .ok_or_else(|| std::io::Error::other("no parent for current executable"))
     })
 }
diff --git a/gix/src/reference/remote.rs b/gix/src/reference/remote.rs
index f2187e748bd..719658a82ab 100644
--- a/gix/src/reference/remote.rs
+++ b/gix/src/reference/remote.rs
@@ -1,9 +1,14 @@
-use crate::bstr::ByteSlice;
-use crate::repository::{branch_remote_ref_name, branch_remote_tracking_ref_name};
-use crate::{remote, Reference};
-use gix_ref::{Category, FullNameRef};
 use std::borrow::Cow;
 
+use gix_ref::{Category, FullNameRef};
+
+use crate::{
+    bstr::ByteSlice,
+    remote,
+    repository::{branch_remote_ref_name, branch_remote_tracking_ref_name},
+    Reference,
+};
+
 /// Remotes
 impl<'repo> Reference<'repo> {
     /// Find the name of our remote for `direction` as configured in `branch.<name>.remote|pushRemote` respectively.
diff --git a/gix/src/remote/connection/fetch/receive_pack.rs b/gix/src/remote/connection/fetch/receive_pack.rs
index e9e932d44a9..579afebdcf3 100644
--- a/gix/src/remote/connection/fetch/receive_pack.rs
+++ b/gix/src/remote/connection/fetch/receive_pack.rs
@@ -1,3 +1,11 @@
+use std::{ops::DerefMut, path::PathBuf, sync::atomic::AtomicBool};
+
+use gix_odb::store::RefreshMode;
+use gix_protocol::{
+    fetch::{negotiate, Arguments},
+    transport::client::Transport,
+};
+
 use crate::{
     config::{
         cache::util::ApplyLeniency,
@@ -10,12 +18,6 @@ use crate::{
         fetch::{negotiate::Algorithm, outcome, refs, Error, Outcome, Prepare, RefLogMessage, Status},
     },
 };
-use gix_odb::store::RefreshMode;
-use gix_protocol::fetch::negotiate;
-use gix_protocol::{fetch::Arguments, transport::client::Transport};
-use std::ops::DerefMut;
-use std::path::PathBuf;
-use std::sync::atomic::AtomicBool;
 
 impl<T> Prepare<'_, '_, T>
 where
diff --git a/gix/src/remote/connection/fetch/update_refs/mod.rs b/gix/src/remote/connection/fetch/update_refs/mod.rs
index 121f9726ad0..c14d5ae26ce 100644
--- a/gix/src/remote/connection/fetch/update_refs/mod.rs
+++ b/gix/src/remote/connection/fetch/update_refs/mod.rs
@@ -157,7 +157,7 @@ pub(crate) fn update(
                                                 .find_object(local_id)?
                                                 .try_into_commit()
                                                 .map_err(|_| ())
-                                                .and_then(|c| c.committer().map(|a| a.time.seconds).map_err(|_| ()))
+                                                .and_then(|c| c.committer().map(|a| a.seconds()).map_err(|_| ()))
                                                 .and_then(|local_commit_time| {
                                                     remote_id
                                                         .to_owned()
diff --git a/gix/src/remote/connection/fetch/update_refs/tests.rs b/gix/src/remote/connection/fetch/update_refs/tests.rs
index e0fa1034e56..e448f3525d4 100644
--- a/gix/src/remote/connection/fetch/update_refs/tests.rs
+++ b/gix/src/remote/connection/fetch/update_refs/tests.rs
@@ -56,9 +56,7 @@ mod update {
         remote::{
             fetch,
             fetch::{
-                refmap::Mapping,
-                refmap::Source,
-                refmap::SpecIndex,
+                refmap::{Mapping, Source, SpecIndex},
                 refs::{tests::restricted, update::TypeChange},
                 RefLogMessage,
             },
diff --git a/gix/src/remote/fetch.rs b/gix/src/remote/fetch.rs
index c822f8f9b09..d695c219c5c 100644
--- a/gix/src/remote/fetch.rs
+++ b/gix/src/remote/fetch.rs
@@ -2,7 +2,6 @@
 pub mod negotiate {
     #[cfg(feature = "credentials")]
     pub use gix_negotiate::Algorithm;
-
     #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
     pub use gix_protocol::fetch::negotiate::Error;
 }
diff --git a/gix/src/remote/mod.rs b/gix/src/remote/mod.rs
index c5d1a273f9f..4d3bc6cf6f9 100644
--- a/gix/src/remote/mod.rs
+++ b/gix/src/remote/mod.rs
@@ -1,6 +1,6 @@
+use std::{borrow::Cow, collections::BTreeSet};
+
 use crate::bstr::BStr;
-use std::borrow::Cow;
-use std::collections::BTreeSet;
 
 /// The direction of an operation carried out (or to be carried out) through a remote.
 #[derive(Debug, Eq, PartialEq, Copy, Clone, Hash)]
diff --git a/gix/src/repository/config/branch.rs b/gix/src/repository/config/branch.rs
index 74bf0a887d1..eadc480861d 100644
--- a/gix/src/repository/config/branch.rs
+++ b/gix/src/repository/config/branch.rs
@@ -2,13 +2,17 @@ use std::{borrow::Cow, collections::BTreeSet};
 
 use gix_ref::{FullName, FullNameRef};
 
-use crate::bstr::BStr;
-use crate::config::cache::util::ApplyLeniencyDefault;
-use crate::config::tree::{Branch, Push};
-use crate::repository::{
-    branch_remote_ref_name, branch_remote_tracking_ref_name, upstream_branch_and_remote_name_for_tracking_branch,
+use crate::{
+    bstr::BStr,
+    config::{
+        cache::util::ApplyLeniencyDefault,
+        tree::{Branch, Push},
+    },
+    push, remote,
+    repository::{
+        branch_remote_ref_name, branch_remote_tracking_ref_name, upstream_branch_and_remote_name_for_tracking_branch,
+    },
 };
-use crate::{push, remote};
 
 /// Query configuration related to branches.
 impl crate::Repository {
diff --git a/gix/src/repository/config/remote.rs b/gix/src/repository/config/remote.rs
index 0b7f69c7ffa..b5a4ae4f61c 100644
--- a/gix/src/repository/config/remote.rs
+++ b/gix/src/repository/config/remote.rs
@@ -1,8 +1,10 @@
-use crate::bstr::BStr;
 use std::borrow::Cow;
 
-use crate::config::tree::{Remote, Section};
-use crate::remote;
+use crate::{
+    bstr::BStr,
+    config::tree::{Remote, Section},
+    remote,
+};
 
 /// Query configuration related to remotes.
 impl crate::Repository {
diff --git a/gix/src/repository/diff.rs b/gix/src/repository/diff.rs
index 5d504187efa..b8fced88d8e 100644
--- a/gix/src/repository/diff.rs
+++ b/gix/src/repository/diff.rs
@@ -1,7 +1,10 @@
-use crate::repository::{diff_resource_cache, diff_tree_to_tree};
-use crate::{Repository, Tree};
 use gix_object::TreeRefIter;
 
+use crate::{
+    repository::{diff_resource_cache, diff_tree_to_tree},
+    Repository, Tree,
+};
+
 /// Diff-utilities
 impl Repository {
     /// Create a resource cache for diffable objects, and configured with everything it needs to know to perform diffs
diff --git a/gix/src/repository/dirwalk.rs b/gix/src/repository/dirwalk.rs
index 2eee2a99816..b71cd567247 100644
--- a/gix/src/repository/dirwalk.rs
+++ b/gix/src/repository/dirwalk.rs
@@ -1,9 +1,13 @@
-use crate::bstr::{BStr, BString};
-use crate::util::OwnedOrStaticAtomicBool;
-use crate::worktree::IndexPersistedOrInMemory;
-use crate::{config, dirwalk, is_dir_to_mode, Repository};
 use std::sync::atomic::AtomicBool;
 
+use crate::{
+    bstr::{BStr, BString},
+    config, dirwalk, is_dir_to_mode,
+    util::OwnedOrStaticAtomicBool,
+    worktree::IndexPersistedOrInMemory,
+    Repository,
+};
+
 impl Repository {
     /// Return default options suitable for performing a directory walk on this repository.
     ///
diff --git a/gix/src/repository/freelist.rs b/gix/src/repository/freelist.rs
index 0ee5bf63f13..9755f3d9e88 100644
--- a/gix/src/repository/freelist.rs
+++ b/gix/src/repository/freelist.rs
@@ -1,5 +1,7 @@
-use std::cell::RefCell;
-use std::ops::{Deref, DerefMut};
+use std::{
+    cell::RefCell,
+    ops::{Deref, DerefMut},
+};
 
 /// A buffer that is returned to the free-list after usage.
 #[derive(Clone)]
diff --git a/gix/src/repository/identity.rs b/gix/src/repository/identity.rs
index a9b3d7899b3..c3385746753 100644
--- a/gix/src/repository/identity.rs
+++ b/gix/src/repository/identity.rs
@@ -1,7 +1,7 @@
 use std::time::SystemTime;
 
 use crate::{
-    bstr::BString,
+    bstr::{BString, ByteSlice},
     config,
     config::tree::{gitoxide, keys, Author, Committer, Key, User},
 };
@@ -38,10 +38,7 @@ impl crate::Repository {
                 .as_ref()
                 .or(p.user.email.as_ref())
                 .map(AsRef::as_ref)?,
-            time: match extract_time_or_default(p.committer.time.as_ref(), &gitoxide::Commit::COMMITTER_DATE) {
-                Ok(t) => t,
-                Err(err) => return Some(Err(err)),
-            },
+            time: p.committer.time.as_ref().map(AsRef::as_ref)?,
         })
         .into()
     }
@@ -63,32 +60,17 @@ impl crate::Repository {
         Ok(gix_actor::SignatureRef {
             name: p.author.name.as_ref().or(p.user.name.as_ref()).map(AsRef::as_ref)?,
             email: p.author.email.as_ref().or(p.user.email.as_ref()).map(AsRef::as_ref)?,
-            time: match extract_time_or_default(p.author.time.as_ref(), &gitoxide::Commit::AUTHOR_DATE) {
-                Ok(t) => t,
-                Err(err) => return Some(Err(err)),
-            },
+            time: p.author.time.as_ref().map(AsRef::as_ref)?,
         })
         .into()
     }
 }
 
-fn extract_time_or_default(
-    time: Option<&Result<gix_date::Time, gix_date::parse::Error>>,
-    config_key: &'static keys::Time,
-) -> Result<gix_date::Time, config::time::Error> {
-    match time {
-        Some(Ok(t)) => Ok(*t),
-        None => Ok(gix_date::Time::now_local_or_utc()),
-        Some(Err(err)) => Err(config::time::Error::from(config_key).with_source(err.clone())),
-    }
-}
-
 #[derive(Debug, Clone)]
 pub(crate) struct Entity {
     pub name: Option<BString>,
     pub email: Option<BString>,
-    /// A time parsed from an environment variable, handling potential errors is delayed.
-    pub time: Option<Result<gix_date::Time, gix_date::parse::Error>>,
+    pub time: Option<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -124,14 +106,23 @@ impl Personas {
                     .map(std::borrow::Cow::into_owned),
             )
         }
-        let now = SystemTime::now();
-        let parse_date = |key: &str, date: &keys::Time| -> Option<Result<gix_date::Time, gix_date::parse::Error>> {
+        let parse_date = |key: &str, date: &keys::Any| -> Option<String> {
             debug_assert_eq!(
                 key,
                 date.logical_name(),
                 "BUG: drift of expected name and actual name of the key (we hardcode it to save an allocation)"
             );
-            config.string(key).map(|time| date.try_into_time(time, now.into()))
+            config
+                .string(key)
+                .map(std::borrow::Cow::into_owned)
+                .and_then(|config_date| {
+                    config_date
+                        .to_str()
+                        .ok()
+                        .and_then(|date| gix_date::parse(date, Some(SystemTime::now())).ok())
+                })
+                .or_else(|| Some(gix_date::Time::now_local_or_utc()))
+                .map(|time| time.format(gix_date::time::Format::Raw))
         };
 
         let fallback = (
diff --git a/gix/src/repository/impls.rs b/gix/src/repository/impls.rs
index 32f319c8199..3b81a778064 100644
--- a/gix/src/repository/impls.rs
+++ b/gix/src/repository/impls.rs
@@ -1,6 +1,7 @@
+use std::ops::DerefMut;
+
 use gix_hash::ObjectId;
 use gix_object::Exists;
-use std::ops::DerefMut;
 
 impl Clone for crate::Repository {
     fn clone(&self) -> Self {
diff --git a/gix/src/repository/index.rs b/gix/src/repository/index.rs
index cfd319b985b..c520ee76f01 100644
--- a/gix/src/repository/index.rs
+++ b/gix/src/repository/index.rs
@@ -1,5 +1,7 @@
 use crate::{
-    config::cache::util::ApplyLeniencyDefault, config::tree::Index, worktree, worktree::IndexPersistedOrInMemory,
+    config::{cache::util::ApplyLeniencyDefault, tree::Index},
+    worktree,
+    worktree::IndexPersistedOrInMemory,
 };
 
 /// Index access
@@ -54,7 +56,10 @@ impl crate::Repository {
             None => Err(worktree::open_index::Error::IndexFile(
                 gix_index::file::init::Error::Io(std::io::Error::new(
                     std::io::ErrorKind::NotFound,
-                    format!("Could not find index file at {:?} for opening.", self.index_path()),
+                    format!(
+                        "Could not find index file at '{index_path}' for opening.",
+                        index_path = self.index_path().display()
+                    ),
                 )),
             )),
         })
diff --git a/gix/src/repository/location.rs b/gix/src/repository/location.rs
index 204e61e6612..e7a18138df3 100644
--- a/gix/src/repository/location.rs
+++ b/gix/src/repository/location.rs
@@ -1,8 +1,9 @@
 use std::path::{Path, PathBuf};
 
-use crate::bstr::BStr;
 use gix_path::realpath::MAX_SYMLINKS;
 
+use crate::bstr::BStr;
+
 impl crate::Repository {
     /// Return the path to the repository itself, containing objects, references, configuration, and more.
     ///
diff --git a/gix/src/repository/mailmap.rs b/gix/src/repository/mailmap.rs
index 9be9345ac65..569aef3fe99 100644
--- a/gix/src/repository/mailmap.rs
+++ b/gix/src/repository/mailmap.rs
@@ -1,5 +1,4 @@
-use crate::config::tree::Mailmap;
-use crate::Id;
+use crate::{config::tree::Mailmap, Id};
 
 impl crate::Repository {
     // TODO: tests
diff --git a/gix/src/repository/merge.rs b/gix/src/repository/merge.rs
index ae9a4b79922..c9da696aa88 100644
--- a/gix/src/repository/merge.rs
+++ b/gix/src/repository/merge.rs
@@ -1,14 +1,17 @@
-use crate::config::cache::util::ApplyLeniencyDefault;
-use crate::config::tree;
-use crate::prelude::ObjectIdExt;
-use crate::repository::{
-    blob_merge_options, merge_commits, merge_resource_cache, merge_trees, tree_merge_options, virtual_merge_base,
-    virtual_merge_base_with_graph,
-};
-use crate::Repository;
+use std::borrow::Cow;
+
 use gix_merge::blob::builtin_driver::text;
 use gix_object::Write;
-use std::borrow::Cow;
+
+use crate::{
+    config::{cache::util::ApplyLeniencyDefault, tree},
+    prelude::ObjectIdExt,
+    repository::{
+        blob_merge_options, merge_commits, merge_resource_cache, merge_trees, tree_merge_options, virtual_merge_base,
+        virtual_merge_base_with_graph,
+    },
+    Repository,
+};
 
 /// Merge-utilities
 impl Repository {
diff --git a/gix/src/repository/object.rs b/gix/src/repository/object.rs
index 2528e1c51cd..6cbd6372d78 100644
--- a/gix/src/repository/object.rs
+++ b/gix/src/repository/object.rs
@@ -249,7 +249,7 @@ impl crate::Repository {
             target: target.as_ref().into(),
             target_kind,
             name: name.as_ref().into(),
-            tagger: tagger.map(|t| t.to_owned()),
+            tagger: tagger.map(|t| t.to_owned()).transpose()?,
             message: message.as_ref().into(),
             pgp_signature: None,
         };
diff --git a/gix/src/repository/revision.rs b/gix/src/repository/revision.rs
index f00774572ca..ca89cd1f166 100644
--- a/gix/src/repository/revision.rs
+++ b/gix/src/repository/revision.rs
@@ -113,8 +113,7 @@ impl crate::Repository {
         commits: impl IntoIterator<Item = impl Into<gix_hash::ObjectId>>,
         graph: &mut gix_revwalk::Graph<'_, '_, gix_revwalk::graph::Commit<gix_revision::merge_base::Flags>>,
     ) -> Result<Id<'_>, crate::repository::merge_base_octopus_with_graph::Error> {
-        use crate::prelude::ObjectIdExt;
-        use crate::repository::merge_base_octopus_with_graph;
+        use crate::{prelude::ObjectIdExt, repository::merge_base_octopus_with_graph};
         let commits: Vec<_> = commits.into_iter().map(Into::into).collect();
         let first = commits
             .first()
diff --git a/gix/src/repository/worktree.rs b/gix/src/repository/worktree.rs
index ae705bf1b57..e3475d2cc45 100644
--- a/gix/src/repository/worktree.rs
+++ b/gix/src/repository/worktree.rs
@@ -131,7 +131,7 @@ impl crate::Repository {
             &mut stream,
             |stream| {
                 if should_interrupt.load(std::sync::atomic::Ordering::Relaxed) {
-                    return Err(std::io::Error::new(std::io::ErrorKind::Other, "Cancelled by user").into());
+                    return Err(std::io::Error::other("Cancelled by user").into());
                 }
                 let res = stream.next_entry();
                 blobs.inc();
diff --git a/gix/src/revision/spec/mod.rs b/gix/src/revision/spec/mod.rs
index fe85c9151d3..4002ee03e53 100644
--- a/gix/src/revision/spec/mod.rs
+++ b/gix/src/revision/spec/mod.rs
@@ -1,5 +1,4 @@
-use crate::bstr::BStr;
-use crate::{ext::ReferenceExt, revision::Spec, Id, Reference};
+use crate::{bstr::BStr, ext::ReferenceExt, revision::Spec, Id, Reference};
 
 ///
 pub mod parse;
diff --git a/gix/src/revision/spec/parse/error.rs b/gix/src/revision/spec/parse/error.rs
index 8a536210bb7..eb361238995 100644
--- a/gix/src/revision/spec/parse/error.rs
+++ b/gix/src/revision/spec/parse/error.rs
@@ -26,7 +26,7 @@ pub enum CandidateInfo {
     /// The candidate is a commit.
     Commit {
         /// The date of the commit.
-        date: gix_date::Time,
+        date: String,
         /// The subject line.
         title: BString,
     },
@@ -39,7 +39,13 @@ impl std::fmt::Display for CandidateInfo {
             CandidateInfo::Tag { name } => write!(f, "tag {name:?}"),
             CandidateInfo::Object { kind } => std::fmt::Display::fmt(kind, f),
             CandidateInfo::Commit { date, title } => {
-                write!(f, "commit {} {title:?}", date.format(gix_date::time::format::SHORT))
+                write!(
+                    f,
+                    "commit {} {title:?}",
+                    gix_date::parse_header(date)
+                        .unwrap_or_default()
+                        .format(gix_date::time::format::SHORT)
+                )
             }
         }
     }
@@ -91,7 +97,7 @@ impl Error {
                                 use bstr::ByteSlice;
                                 let commit = obj.to_commit_ref();
                                 CandidateInfo::Commit {
-                                    date: commit.committer().time,
+                                    date: commit.committer().time.trim().into(),
                                     title: commit.message().title.trim().into(),
                                 }
                             }
diff --git a/gix/src/revision/spec/parse/mod.rs b/gix/src/revision/spec/parse/mod.rs
index 465d3fd9997..68cdf5e7ea3 100644
--- a/gix/src/revision/spec/parse/mod.rs
+++ b/gix/src/revision/spec/parse/mod.rs
@@ -6,9 +6,10 @@ use gix_revision::spec::parse;
 use crate::{bstr::BStr, revision::Spec, Repository};
 
 mod types;
-use crate::bstr::BString;
 pub use types::{Error, ObjectKindHint, Options, RefsHint};
 
+use crate::bstr::BString;
+
 ///
 pub mod single {
     use crate::bstr::BString;
diff --git a/gix/src/status/index_worktree.rs b/gix/src/status/index_worktree.rs
index 27fd952d961..86a7dccc877 100644
--- a/gix/src/status/index_worktree.rs
+++ b/gix/src/status/index_worktree.rs
@@ -1,8 +1,12 @@
-use crate::bstr::{BStr, BString};
-use crate::{config, Repository};
-use gix_status::index_as_worktree::traits::{CompareBlobs, SubmoduleStatus};
 use std::sync::atomic::AtomicBool;
 
+use gix_status::index_as_worktree::traits::{CompareBlobs, SubmoduleStatus};
+
+use crate::{
+    bstr::{BStr, BString},
+    config, Repository,
+};
+
 /// The error returned by [Repository::index_worktree_status()].
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
@@ -200,12 +204,14 @@ pub struct BuiltinSubmoduleStatus {
 
 ///
 mod submodule_status {
-    use crate::bstr;
-    use crate::bstr::BStr;
-    use crate::status::index_worktree::BuiltinSubmoduleStatus;
-    use crate::status::Submodule;
     use std::borrow::Cow;
 
+    use crate::{
+        bstr,
+        bstr::BStr,
+        status::{index_worktree::BuiltinSubmoduleStatus, Submodule},
+    };
+
     impl BuiltinSubmoduleStatus {
         /// Create a new instance from a `repo` and a `mode` to control how the submodule status will be obtained.
         pub fn new(
@@ -411,12 +417,14 @@ pub enum RewriteSource {
 
 ///
 pub mod iter {
-    use crate::bstr::{BStr, BString};
-    use crate::status::{index_worktree, Platform};
     use gix_status::index_as_worktree::{Change, EntryStatus};
+    pub use gix_status::index_as_worktree_with_renames::Summary;
 
     use super::{Item, RewriteSource};
-    pub use gix_status::index_as_worktree_with_renames::Summary;
+    use crate::{
+        bstr::{BStr, BString},
+        status::{index_worktree, Platform},
+    };
 
     /// Access
     impl RewriteSource {
diff --git a/gix/src/status/iter/mod.rs b/gix/src/status/iter/mod.rs
index adadc1aa69f..5391138421d 100644
--- a/gix/src/status/iter/mod.rs
+++ b/gix/src/status/iter/mod.rs
@@ -1,11 +1,14 @@
-use crate::bstr::BString;
-use crate::config::cache::util::ApplyLeniencyDefault;
-use crate::status::index_worktree::BuiltinSubmoduleStatus;
-use crate::status::{index_worktree, tree_index, Platform};
-use crate::worktree::IndexPersistedOrInMemory;
-use gix_status::index_as_worktree::{Change, EntryStatus};
 use std::sync::atomic::Ordering;
 
+use gix_status::index_as_worktree::{Change, EntryStatus};
+
+use crate::{
+    bstr::BString,
+    config::cache::util::ApplyLeniencyDefault,
+    status::{index_worktree, index_worktree::BuiltinSubmoduleStatus, tree_index, Platform},
+    worktree::IndexPersistedOrInMemory,
+};
+
 pub(super) mod types;
 use types::{ApplyChange, Item, Iter, Outcome};
 
diff --git a/gix/src/status/iter/types.rs b/gix/src/status/iter/types.rs
index c5986559cda..1ee9e17ea4d 100644
--- a/gix/src/status/iter/types.rs
+++ b/gix/src/status/iter/types.rs
@@ -1,6 +1,8 @@
-use crate::bstr::BStr;
-use crate::status::{index_worktree, tree_index};
-use crate::worktree::IndexPersistedOrInMemory;
+use crate::{
+    bstr::BStr,
+    status::{index_worktree, tree_index},
+    worktree::IndexPersistedOrInMemory,
+};
 
 /// An iterator for changes between the index and the worktree and the head-tree and the index.
 ///
diff --git a/gix/src/status/mod.rs b/gix/src/status/mod.rs
index 5e6bfdc3777..fd7b60a442c 100644
--- a/gix/src/status/mod.rs
+++ b/gix/src/status/mod.rs
@@ -1,8 +1,7 @@
-use crate::config::cache::util::ApplyLeniencyDefault;
-use crate::util::OwnedOrStaticAtomicBool;
-use crate::{config, Repository};
 pub use gix_status as plumbing;
 
+use crate::{config, config::cache::util::ApplyLeniencyDefault, util::OwnedOrStaticAtomicBool, Repository};
+
 /// A structure to hold options configuring the status request, which can then be turned into an iterator.
 pub struct Platform<'repo, Progress>
 where
@@ -133,9 +132,10 @@ impl Repository {
 
 ///
 pub mod is_dirty {
-    use crate::Repository;
     use std::convert::Infallible;
 
+    use crate::Repository;
+
     /// The error returned by [Repository::is_dirty()].
     #[derive(Debug, thiserror::Error)]
     #[allow(missing_docs)]
diff --git a/gix/src/status/platform.rs b/gix/src/status/platform.rs
index b9086152c46..ececa94611e 100644
--- a/gix/src/status/platform.rs
+++ b/gix/src/status/platform.rs
@@ -1,6 +1,7 @@
-use crate::status::{index_worktree, tree_index, OwnedOrStaticAtomicBool, Platform, Submodule, UntrackedFiles};
 use std::sync::atomic::AtomicBool;
 
+use crate::status::{index_worktree, tree_index, OwnedOrStaticAtomicBool, Platform, Submodule, UntrackedFiles};
+
 /// Builder
 impl<Progress> Platform<'_, Progress>
 where
diff --git a/gix/src/status/tree_index.rs b/gix/src/status/tree_index.rs
index 57850d8b149..35c7c0cb7d1 100644
--- a/gix/src/status/tree_index.rs
+++ b/gix/src/status/tree_index.rs
@@ -1,5 +1,4 @@
-use crate::config::tree;
-use crate::Repository;
+use crate::{config::tree, Repository};
 
 /// The error returned by [Repository::tree_index_status()].
 #[derive(Debug, thiserror::Error)]
diff --git a/gix/src/submodule/mod.rs b/gix/src/submodule/mod.rs
index 5b86ea2ad45..29f95f81024 100644
--- a/gix/src/submodule/mod.rs
+++ b/gix/src/submodule/mod.rs
@@ -278,9 +278,10 @@ impl Submodule<'_> {
 ///
 #[cfg(feature = "status")]
 pub mod status {
+    use gix_submodule::config;
+
     use super::{head_id, index_id, open, Status};
     use crate::Submodule;
-    use gix_submodule::config;
 
     /// The error returned by [Submodule::status()].
     #[derive(Debug, thiserror::Error)]
diff --git a/gix/src/tag.rs b/gix/src/tag.rs
index b22af2334cf..a69819b510f 100644
--- a/gix/src/tag.rs
+++ b/gix/src/tag.rs
@@ -12,6 +12,8 @@ mod error {
         WriteObject(#[from] crate::object::write::Error),
         #[error(transparent)]
         ReferenceEdit(#[from] crate::reference::edit::Error),
+        #[error(transparent)]
+        DateParseError(#[from] gix_date::parse::Error),
     }
 }
 pub use error::Error;
diff --git a/gix/src/util.rs b/gix/src/util.rs
index ad35e71a4b0..c628cdc64c4 100644
--- a/gix/src/util.rs
+++ b/gix/src/util.rs
@@ -1,6 +1,7 @@
-use std::ops::Deref;
-use std::sync::atomic::AtomicBool;
-use std::sync::Arc;
+use std::{
+    ops::Deref,
+    sync::{atomic::AtomicBool, Arc},
+};
 
 #[derive(Clone)]
 pub enum OwnedOrStaticAtomicBool {
diff --git a/gix/tests/gix/clone.rs b/gix/tests/gix/clone.rs
index e3ab68ffc19..ce9d47de3a5 100644
--- a/gix/tests/gix/clone.rs
+++ b/gix/tests/gix/clone.rs
@@ -2,8 +2,7 @@ use crate::{remote, util::restricted};
 
 #[cfg(all(feature = "worktree-mutation", feature = "blocking-network-client"))]
 mod blocking_io {
-    use std::path::Path;
-    use std::{borrow::Cow, sync::atomic::AtomicBool};
+    use std::{borrow::Cow, path::Path, sync::atomic::AtomicBool};
 
     use gix::{
         bstr::BString,
@@ -334,7 +333,7 @@ mod blocking_io {
             .next()
             .expect("one line")?
             .signature
-            .to_owned();
+            .to_owned()?;
         assert_eq!(sig.name, "no name configured during clone");
         assert_eq!(sig.email, "noEmailAvailable@example.com");
 
diff --git a/gix/tests/gix/commit.rs b/gix/tests/gix/commit.rs
index 3daf74852db..2d05ef95096 100644
--- a/gix/tests/gix/commit.rs
+++ b/gix/tests/gix/commit.rs
@@ -6,9 +6,10 @@ mod describe {
 
     #[cfg(feature = "status")]
     mod with_dirty_suffix {
-        use crate::util::named_subrepo_opts;
         use gix::commit::describe::SelectRef;
 
+        use crate::util::named_subrepo_opts;
+
         #[test]
         fn dirty_suffix_applies_automatically_if_dirty() -> crate::Result {
             let repo = named_subrepo_opts(
diff --git a/gix/tests/gix/config/tree.rs b/gix/tests/gix/config/tree.rs
index c4fb8b8226c..686f26f461d 100644
--- a/gix/tests/gix/config/tree.rs
+++ b/gix/tests/gix/config/tree.rs
@@ -147,9 +147,9 @@ mod ssh {
 
 #[cfg(feature = "status")]
 mod status {
+    use gix::{config::tree::Status, status::UntrackedFiles};
+
     use crate::config::tree::bcow;
-    use gix::config::tree::Status;
-    use gix::status::UntrackedFiles;
 
     #[test]
     fn default() -> crate::Result {
@@ -177,9 +177,9 @@ mod status {
 }
 
 mod push {
+    use gix::{config::tree::Push, push};
+
     use crate::config::tree::bcow;
-    use gix::config::tree::Push;
-    use gix::push;
 
     #[test]
     fn default() -> crate::Result {
@@ -367,10 +367,11 @@ mod diff {
 
 #[cfg(feature = "merge")]
 mod merge {
-    use crate::config::tree::bcow;
     use gix::config::tree::{Key, Merge};
     use gix_merge::blob::builtin_driver::text::ConflictStyle;
 
+    use crate::config::tree::bcow;
+
     #[test]
     fn conflict_style() -> crate::Result {
         for (actual, expected) in [
diff --git a/gix/tests/gix/main.rs b/gix/tests/gix/main.rs
index d47cb2ccf07..3b0dc18fa79 100644
--- a/gix/tests/gix/main.rs
+++ b/gix/tests/gix/main.rs
@@ -1,4 +1,4 @@
-#![allow(clippy::result_large_err)]
+#![allow(clippy::result_large_err, clippy::unnecessary_debug_formatting)]
 mod util;
 use util::*;
 
diff --git a/gix/tests/gix/object/tree/diff.rs b/gix/tests/gix/object/tree/diff.rs
index ce6401c83f4..6a260ce403a 100644
--- a/gix/tests/gix/object/tree/diff.rs
+++ b/gix/tests/gix/object/tree/diff.rs
@@ -121,8 +121,7 @@ fn changes_against_tree_modified() -> crate::Result {
 }
 
 mod track_rewrites {
-    use std::collections::HashMap;
-    use std::convert::Infallible;
+    use std::{collections::HashMap, convert::Infallible};
 
     use gix::{
         diff::{
@@ -133,8 +132,7 @@ mod track_rewrites {
     };
     use gix_ref::bstr::BStr;
 
-    use crate::object::tree::diff::tree_named;
-    use crate::util::named_subrepo_opts;
+    use crate::{object::tree::diff::tree_named, util::named_subrepo_opts};
 
     #[test]
     #[cfg_attr(
diff --git a/gix/tests/gix/remote/fetch.rs b/gix/tests/gix/remote/fetch.rs
index 7d5893f2758..f0519a23098 100644
--- a/gix/tests/gix/remote/fetch.rs
+++ b/gix/tests/gix/remote/fetch.rs
@@ -88,8 +88,7 @@ mod blocking_and_async_io {
     #[test]
     #[cfg(feature = "blocking-network-client")]
     fn fetch_more_packs_than_can_be_handled() -> gix_testtools::Result {
-        use gix::config::tree::User;
-        use gix::interrupt::IS_INTERRUPTED;
+        use gix::{config::tree::User, interrupt::IS_INTERRUPTED};
         use gix_odb::store::init::Slots;
         use gix_testtools::tempfile;
         fn create_empty_commit(repo: &gix::Repository) -> anyhow::Result<()> {
diff --git a/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs b/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
index 132a726a23d..c7c307e0bbd 100644
--- a/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
+++ b/gix/tests/gix/repository/config/config_snapshot/credential_helpers.rs
@@ -94,9 +94,11 @@ mod baseline {
 
         let ctx = action.context_mut().expect("get/fill");
         ctx.destructure_url_in_place(cascade.use_http_path).unwrap();
-        let expected_prompt = lowercase_prompt_host
-            .then(|| expected.prompt_url.to_ascii_lowercase())
-            .unwrap_or_else(|| expected.prompt_url.to_owned());
+        let expected_prompt = if lowercase_prompt_host {
+            expected.prompt_url.to_ascii_lowercase()
+        } else {
+            expected.prompt_url.to_owned()
+        };
         if ignore_expected_prompt_port {
             assert_eq!(
                 ctx.to_url().expect("parts complete"),
diff --git a/gix/tests/gix/repository/config/identity.rs b/gix/tests/gix/repository/config/identity.rs
index bfabf2046dd..9ab88879b71 100644
--- a/gix/tests/gix/repository/config/identity.rs
+++ b/gix/tests/gix/repository/config/identity.rs
@@ -1,9 +1,10 @@
-use crate::named_repo;
-use crate::util::named_subrepo_opts;
+use std::path::Path;
+
 use gix_sec::Permission;
 use gix_testtools::Env;
 use serial_test::serial;
-use std::path::Path;
+
+use crate::{named_repo, util::named_subrepo_opts};
 
 #[test]
 #[serial]
@@ -54,11 +55,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
             gix_actor::SignatureRef {
                 name: "author".into(),
                 email: "author@email".into(),
-                time: gix_date::Time {
-                    seconds: 1659329106,
-                    offset: 28800,
-                    sign: gix_date::time::Sign::Plus
-                }
+                time: "1659329106 +0800",
             }
         );
 
@@ -67,11 +64,7 @@ fn author_and_committer_and_fallback() -> crate::Result {
             gix_actor::SignatureRef {
                 name: "committer".into(),
                 email: "committer@email".into(),
-                time: gix_date::Time {
-                    seconds: 1659365106,
-                    offset: -7200,
-                    sign: gix_date::time::Sign::Minus
-                }
+                time: "1659365106 -0200",
             }
         );
         let config = repo.config_snapshot();
@@ -169,11 +162,7 @@ fn author_from_different_config_sections() -> crate::Result {
         Some(gix_actor::SignatureRef {
             name: "global name".into(),
             email: "local@example.com".into(),
-            time: gix_date::Time {
-                seconds: 42,
-                offset: 1800,
-                sign: gix_date::time::Sign::Plus
-            }
+            time: "42 +0030",
         }),
         "author name comes from global config, \
          but email comes from repository-local config",
@@ -183,11 +172,7 @@ fn author_from_different_config_sections() -> crate::Result {
         Some(gix_actor::SignatureRef {
             name: "local committer".into(),
             email: "global-committer@example.com".into(),
-            time: gix_date::Time {
-                seconds: 320437800,
-                offset: 0,
-                sign: gix_date::time::Sign::Plus,
-            }
+            time: "320437800 +0000",
         }),
         "committer name comes from repository-local config, \
          but committer email comes from global config"
diff --git a/gix/tests/gix/repository/config/remote.rs b/gix/tests/gix/repository/config/remote.rs
index fe4f3f1a2a6..fd09592f289 100644
--- a/gix/tests/gix/repository/config/remote.rs
+++ b/gix/tests/gix/repository/config/remote.rs
@@ -1,6 +1,7 @@
-use gix::bstr::BStr;
 use std::borrow::Cow;
 
+use gix::bstr::BStr;
+
 use crate::remote;
 
 fn remote_names<'a>(it: impl IntoIterator<Item = &'a str>) -> Vec<Cow<'a, BStr>> {
@@ -53,14 +54,15 @@ fn remote_default_name() {
 }
 
 mod branch_remote {
+    use gix::{config::tree::Push, remote};
+
     use crate::util::named_subrepo_opts;
-    use gix::config::tree::Push;
-    use gix::remote;
 
     mod name {
-        use crate::repository::config::remote::branch_remote::repo;
         use gix::remote;
 
+        use crate::repository::config::remote::branch_remote::repo;
+
         #[test]
         fn push() -> crate::Result {
             {
diff --git a/gix/tests/gix/repository/excludes.rs b/gix/tests/gix/repository/excludes.rs
index 0ae733c32cc..60f70beed96 100644
--- a/gix/tests/gix/repository/excludes.rs
+++ b/gix/tests/gix/repository/excludes.rs
@@ -1,6 +1,7 @@
-use crate::util::named_subrepo_opts;
 use gix_worktree::stack::state::ignore::Source;
 
+use crate::util::named_subrepo_opts;
+
 #[test]
 fn empty_core_excludes() -> crate::Result {
     let repo = named_subrepo_opts(
diff --git a/gix/tests/gix/repository/mod.rs b/gix/tests/gix/repository/mod.rs
index 7a0c05fde67..cf29cfc1170 100644
--- a/gix/tests/gix/repository/mod.rs
+++ b/gix/tests/gix/repository/mod.rs
@@ -62,10 +62,10 @@ mod index {
 
 #[cfg(feature = "dirwalk")]
 mod dirwalk {
-    use gix_dir::entry::Kind::*;
-    use gix_dir::walk::EmissionMode;
     use std::sync::atomic::AtomicBool;
 
+    use gix_dir::{entry::Kind::*, walk::EmissionMode};
+
     #[test]
     fn basics() -> crate::Result {
         let repo = crate::named_repo("make_basic_repo.sh")?;
diff --git a/gix/tests/gix/repository/object.rs b/gix/tests/gix/repository/object.rs
index 54878ccf4f2..8c0c3234ad6 100644
--- a/gix/tests/gix/repository/object.rs
+++ b/gix/tests/gix/repository/object.rs
@@ -1,6 +1,7 @@
-use crate::util::named_subrepo_opts;
 use gix_testtools::tempfile;
 
+use crate::util::named_subrepo_opts;
+
 mod object_database_impl {
     use gix_object::{Exists, Find, FindHeader};
 
@@ -29,10 +30,11 @@ mod object_database_impl {
 
 #[cfg(feature = "tree-editor")]
 mod edit_tree {
-    use crate::util::hex_to_id;
     use gix::bstr::{BStr, BString};
     use gix_object::tree::EntryKind;
 
+    use crate::util::hex_to_id;
+
     #[test]
     // Some part of the test validation the implementation for this exists, but it's needless nonetheless.
     #[allow(clippy::needless_borrows_for_generic_args)]
@@ -203,8 +205,10 @@ mod edit_tree {
     }
 
     mod utils {
-        use gix::bstr::{BStr, ByteSlice};
-        use gix::Repository;
+        use gix::{
+            bstr::{BStr, ByteSlice},
+            Repository,
+        };
         use gix_hash::ObjectId;
 
         fn display_tree_recursive(
@@ -290,8 +294,10 @@ mod write_object {
 mod write_blob {
     use std::io::{Seek, SeekFrom};
 
-    use crate::repository::object::empty_bare_repo;
-    use crate::{repository::object::empty_bare_in_memory_repo, util::hex_to_id};
+    use crate::{
+        repository::object::{empty_bare_in_memory_repo, empty_bare_repo},
+        util::hex_to_id,
+    };
 
     #[test]
     fn from_slice() -> crate::Result {
@@ -534,6 +540,7 @@ mod tag {
 }
 
 mod commit_as {
+    use gix_date::parse::TimeBuf;
     use gix_testtools::tempfile;
 
     #[test]
@@ -550,17 +557,17 @@ mod commit_as {
         let committer = gix::actor::Signature {
             name: "c".into(),
             email: "c@example.com".into(),
-            time: gix::date::Time::new(1, 1800),
+            time: gix_date::parse_header("1 +0030").unwrap(),
         };
         let author = gix::actor::Signature {
             name: "a".into(),
             email: "a@example.com".into(),
-            time: gix::date::Time::new(3, 3600),
+            time: gix_date::parse_header("3 +0100").unwrap(),
         };
 
         let commit_id = repo.commit_as(
-            &committer,
-            &author,
+            committer.to_ref(&mut TimeBuf::default()),
+            author.to_ref(&mut TimeBuf::default()),
             "HEAD",
             "initial",
             empty_tree.id,
@@ -568,8 +575,9 @@ mod commit_as {
         )?;
         let commit = commit_id.object()?.into_commit();
 
-        assert_eq!(commit.committer()?, committer.to_ref());
-        assert_eq!(commit.author()?, author.to_ref());
+        let mut buf = TimeBuf::default();
+        assert_eq!(commit.committer()?, committer.to_ref(&mut buf));
+        assert_eq!(commit.author()?, author.to_ref(&mut buf));
         Ok(())
     }
 }
diff --git a/gix/tests/gix/repository/open.rs b/gix/tests/gix/repository/open.rs
index d60227414da..48eea8ad821 100644
--- a/gix/tests/gix/repository/open.rs
+++ b/gix/tests/gix/repository/open.rs
@@ -1,7 +1,8 @@
-use crate::util::named_subrepo_opts;
+use std::{borrow::Cow, error::Error};
+
 use gix::bstr::BString;
-use std::borrow::Cow;
-use std::error::Error;
+
+use crate::util::named_subrepo_opts;
 
 #[test]
 fn on_root_with_decomposed_unicode() -> crate::Result {
diff --git a/gix/tests/gix/revision/spec/from_bytes/mod.rs b/gix/tests/gix/revision/spec/from_bytes/mod.rs
index 3c916cdb671..407227f2f6b 100644
--- a/gix/tests/gix/revision/spec/from_bytes/mod.rs
+++ b/gix/tests/gix/revision/spec/from_bytes/mod.rs
@@ -13,8 +13,10 @@ mod traverse;
 mod peel;
 
 mod sibling_branch {
-    use crate::revision::spec::from_bytes::{parse_spec, repo};
-    use crate::util::hex_to_id;
+    use crate::{
+        revision::spec::from_bytes::{parse_spec, repo},
+        util::hex_to_id,
+    };
 
     #[test]
     fn push_and_upstream() -> crate::Result {
diff --git a/gix/tests/gix/status.rs b/gix/tests/gix/status.rs
index e8352323a17..e28743e3036 100644
--- a/gix/tests/gix/status.rs
+++ b/gix/tests/gix/status.rs
@@ -17,13 +17,15 @@ pub fn repo(name: &str) -> crate::Result<gix::Repository> {
 }
 
 mod into_iter {
-    use crate::status::{repo, submodule_repo};
-    use crate::util::hex_to_id;
-    use gix::status::tree_index::TrackRenames;
-    use gix::status::Item;
+    use gix::status::{tree_index::TrackRenames, Item};
     use gix_diff::Rewrites;
     use gix_testtools::size_ok;
 
+    use crate::{
+        status::{repo, submodule_repo},
+        util::hex_to_id,
+    };
+
     #[test]
     fn item_size() {
         let actual = std::mem::size_of::<Item>();
@@ -167,11 +169,12 @@ mod into_iter {
 
 mod index_worktree {
     mod iter {
-        use crate::status::{repo, submodule_repo};
         use gix::status::index_worktree::Item;
         use gix_testtools::size_ok;
         use pretty_assertions::assert_eq;
 
+        use crate::status::{repo, submodule_repo};
+
         #[test]
         fn item_size() {
             let actual = std::mem::size_of::<Item>();
diff --git a/gix/tests/gix/submodule.rs b/gix/tests/gix/submodule.rs
index b9de22937cd..597c97948ce 100644
--- a/gix/tests/gix/submodule.rs
+++ b/gix/tests/gix/submodule.rs
@@ -127,8 +127,7 @@ mod open {
 
     #[cfg(feature = "status")]
     mod status {
-        use crate::submodule::repo;
-        use crate::util::hex_to_id;
+        use crate::{submodule::repo, util::hex_to_id};
 
         #[test]
         fn changed_head_compared_to_superproject_index() -> crate::Result {
diff --git a/justfile b/justfile
index a47466ce1ee..777a04d3d6d 100755
--- a/justfile
+++ b/justfile
@@ -236,8 +236,7 @@ cross-test target options test-options: (cross-image target)
 cross-test-s390x: (cross-test 's390x-unknown-linux-gnu' '' '')
 
 # Test Android with `cross` (max-pure)
-cross-test-android: (cross-test 'armv7-linux-androideabi'
-                     '--no-default-features --features max-pure' '')
+cross-test-android: (cross-test 'armv7-linux-androideabi' '--no-default-features --features max-pure' '')
 
 # Run `cargo diet` on all crates to see that they are still in bounds
 check-size:
diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index fad69987f3f..7e858fd1d8a 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -7,20 +7,21 @@ use std::{
     },
 };
 
-use crate::shared::pretty::prepare_and_run;
 use anyhow::{anyhow, Context, Result};
 use clap::{CommandFactory, Parser};
 use gitoxide_core as core;
 use gitoxide_core::{pack::verify, repository::PathsOrPatterns};
 use gix::bstr::{io::BufReadExt, BString};
 
-use crate::plumbing::options::merge;
-use crate::plumbing::{
-    options::{
-        attributes, commit, commitgraph, config, credential, exclude, free, fsck, index, mailmap, odb, revision, tree,
-        Args, Subcommands,
+use crate::{
+    plumbing::{
+        options::{
+            attributes, commit, commitgraph, config, credential, exclude, free, fsck, index, mailmap, merge, odb,
+            revision, tree, Args, Subcommands,
+        },
+        show_progress,
     },
-    show_progress,
+    shared::pretty::prepare_and_run,
 };
 
 #[cfg(feature = "gitoxide-core-async-client")]
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
index a9b48f739bf..ab12f3f691b 100644
--- a/src/plumbing/options/mod.rs
+++ b/src/plumbing/options/mod.rs
@@ -234,9 +234,10 @@ pub mod archive {
 }
 
 pub mod status {
-    use crate::shared::{CheckPathSpec, ParseRenameFraction};
     use gix::bstr::BString;
 
+    use crate::shared::{CheckPathSpec, ParseRenameFraction};
+
     #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
     pub enum Submodules {
         /// display all information about submodules, including ref changes, modifications and untracked files.
@@ -763,9 +764,10 @@ pub mod mailmap {
 
 #[cfg(feature = "gitoxide-core-tools-clean")]
 pub mod clean {
-    use crate::shared::CheckPathSpec;
     use gix::bstr::BString;
 
+    use crate::shared::CheckPathSpec;
+
     #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
     pub enum FindRepository {
         All,
@@ -1035,9 +1037,10 @@ pub mod revision {
 }
 
 pub mod attributes {
-    use crate::shared::CheckPathSpec;
     use gix::bstr::BString;
 
+    use crate::shared::CheckPathSpec;
+
     #[derive(Debug, clap::Subcommand)]
     pub enum Subcommands {
         /// Run `git check-attr` and `git check-ignore` on all files of the index or all files
@@ -1065,9 +1068,10 @@ pub mod attributes {
 pub mod exclude {
     use std::ffi::OsString;
 
-    use crate::shared::CheckPathSpec;
     use gix::bstr::BString;
 
+    use crate::shared::CheckPathSpec;
+
     #[derive(Debug, clap::Subcommand)]
     pub enum Subcommands {
         /// Check if path-specs are excluded and print the result similar to `git check-ignore`.
@@ -1095,9 +1099,10 @@ pub mod exclude {
 pub mod index {
     use std::path::PathBuf;
 
-    use crate::shared::CheckPathSpec;
     use gix::bstr::BString;
 
+    use crate::shared::CheckPathSpec;
+
     pub mod entries {
         #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, clap::ValueEnum)]
         pub enum Format {
diff --git a/src/plumbing/progress.rs b/src/plumbing/progress.rs
index 117dc3cae2e..ddfa9fde8f6 100644
--- a/src/plumbing/progress.rs
+++ b/src/plumbing/progress.rs
@@ -1,5 +1,7 @@
-use std::fmt::{Display, Formatter};
-use std::io::StdoutLock;
+use std::{
+    fmt::{Display, Formatter},
+    io::StdoutLock,
+};
 
 #[derive(Clone)]
 enum Usage {
diff --git a/src/porcelain/main.rs b/src/porcelain/main.rs
index 3bd15362b07..2c3d5d69423 100644
--- a/src/porcelain/main.rs
+++ b/src/porcelain/main.rs
@@ -3,12 +3,14 @@ use std::sync::{
     Arc,
 };
 
-use crate::shared::pretty::prepare_and_run;
 use anyhow::{anyhow, Result};
 use clap::{CommandFactory, Parser};
 use gitoxide_core as core;
 
-use crate::porcelain::options::{Args, Subcommands};
+use crate::{
+    porcelain::options::{Args, Subcommands},
+    shared::pretty::prepare_and_run,
+};
 
 pub fn main() -> Result<()> {
     let args: Args = Args::parse_from(gix::env::args_os());
diff --git a/src/porcelain/options.rs b/src/porcelain/options.rs
index d1e1b9d82eb..75c287e7bac 100644
--- a/src/porcelain/options.rs
+++ b/src/porcelain/options.rs
@@ -1,6 +1,7 @@
-use clap_complete::Shell;
 use std::path::PathBuf;
 
+use clap_complete::Shell;
+
 #[derive(Debug, clap::Parser)]
 #[clap(name = "ein", about = "The rusty git", version = option_env!("GIX_VERSION"))]
 #[clap(subcommand_required = true)]
diff --git a/src/shared.rs b/src/shared.rs
index a40ecd24d2a..765e9df6936 100644
--- a/src/shared.rs
+++ b/src/shared.rs
@@ -441,9 +441,10 @@ pub use self::clap::{
 
 #[cfg(test)]
 mod value_parser_tests {
-    use super::{AsRange, AsTime, ParseRenameFraction};
     use clap::Parser;
 
+    use super::{AsRange, AsTime, ParseRenameFraction};
+
     #[test]
     fn rename_fraction() {
         #[derive(Debug, clap::Parser)]
diff --git a/tests/it/src/args.rs b/tests/it/src/args.rs
index 537842ed328..85c95d92648 100644
--- a/tests/it/src/args.rs
+++ b/tests/it/src/args.rs
@@ -1,7 +1,9 @@
-use clap::builder::{OsStringValueParser, TypedValueParser};
-use clap::{Arg, Command, Error};
-use std::ffi::OsStr;
-use std::path::PathBuf;
+use std::{ffi::OsStr, path::PathBuf};
+
+use clap::{
+    builder::{OsStringValueParser, TypedValueParser},
+    Arg, Command, Error,
+};
 
 #[derive(Debug, clap::Parser)]
 #[clap(name = "it", about = "internal tools to help create test cases")]
diff --git a/tests/it/src/commands/check_mode.rs b/tests/it/src/commands/check_mode.rs
index 35f95d78cad..3a3e4afee1a 100644
--- a/tests/it/src/commands/check_mode.rs
+++ b/tests/it/src/commands/check_mode.rs
@@ -1,11 +1,14 @@
 pub(super) mod function {
+    use std::{
+        ffi::{OsStr, OsString},
+        io::{BufRead, BufReader, Read},
+        process::{Command, Stdio},
+    };
+
     use anyhow::{bail, Context};
     use gix::bstr::ByteSlice;
     use once_cell::sync::Lazy;
     use regex::bytes::Regex;
-    use std::ffi::{OsStr, OsString};
-    use std::io::{BufRead, BufReader, Read};
-    use std::process::{Command, Stdio};
 
     pub fn check_mode() -> anyhow::Result<()> {
         let root = find_root()?;
diff --git a/tests/it/src/commands/copy_royal.rs b/tests/it/src/commands/copy_royal.rs
index 3cebae566df..faefd991a4c 100644
--- a/tests/it/src/commands/copy_royal.rs
+++ b/tests/it/src/commands/copy_royal.rs
@@ -1,9 +1,9 @@
 pub(super) mod function {
-    use anyhow::Context;
-    use gix::fs::Stack;
-    use gix::pathspec::Pattern;
     use std::path::{Path, PathBuf};
 
+    use anyhow::Context;
+    use gix::{fs::Stack, pathspec::Pattern};
+
     pub fn copy_royal(
         dry_run: bool,
         worktree_dir: &Path,
diff --git a/tests/it/src/commands/git_to_sh.rs b/tests/it/src/commands/git_to_sh.rs
index 85ef05eec9c..590d1f5dfbd 100644
--- a/tests/it/src/commands/git_to_sh.rs
+++ b/tests/it/src/commands/git_to_sh.rs
@@ -5,11 +5,10 @@ pub struct Options {
 }
 
 pub(super) mod function {
+    use std::{borrow::Cow, path::Path};
+
     use anyhow::{bail, Context};
-    use gix::object::tree::EntryKind;
-    use gix::objs::FindExt;
-    use std::borrow::Cow;
-    use std::path::Path;
+    use gix::{object::tree::EntryKind, objs::FindExt};
 
     use super::Options;
 
diff --git a/tests/snapshots/panic-behaviour/expected-failure b/tests/snapshots/panic-behaviour/expected-failure
index 0cf65deb235..179a2b9d568 100644
--- a/tests/snapshots/panic-behaviour/expected-failure
+++ b/tests/snapshots/panic-behaviour/expected-failure
@@ -1,4 +1,4 @@
 
-thread 'main' panicked at src/porcelain/main.rs:40:42:
+thread 'main' panicked at src/porcelain/main.rs:42:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
\ No newline at end of file
diff --git a/tests/snapshots/panic-behaviour/expected-failure-in-thread b/tests/snapshots/panic-behaviour/expected-failure-in-thread
index 2c58afa0cea..0e7cf34d3d2 100644
--- a/tests/snapshots/panic-behaviour/expected-failure-in-thread
+++ b/tests/snapshots/panic-behaviour/expected-failure-in-thread
@@ -1,5 +1,5 @@
 
-thread 'main' panicked at src/porcelain/main.rs:40:42:
+thread 'main' panicked at src/porcelain/main.rs:42:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 
\ No newline at end of file
diff --git a/tests/snapshots/panic-behaviour/expected-failure-in-thread-with-progress b/tests/snapshots/panic-behaviour/expected-failure-in-thread-with-progress
index aaf85f87371..966a4fe6ca4 100644
--- a/tests/snapshots/panic-behaviour/expected-failure-in-thread-with-progress
+++ b/tests/snapshots/panic-behaviour/expected-failure-in-thread-with-progress
@@ -1,5 +1,5 @@
 [?1049h[?25l
-thread '<unnamed>' panicked at src/porcelain/main.rs:40:42:
+thread '<unnamed>' panicked at src/porcelain/main.rs:42:42:
 something went very wrong
 note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
 [?25h[?1049l
\ No newline at end of file
diff --git a/tests/snapshots/plumbing/no-repo/pack/explode/broken-with-objects-dir-skip-checks-success-tree b/tests/snapshots/plumbing/no-repo/pack/explode/broken-with-objects-dir-skip-checks-success-tree
new file mode 100644
index 00000000000..da10cdb1f27
--- /dev/null
+++ b/tests/snapshots/plumbing/no-repo/pack/explode/broken-with-objects-dir-skip-checks-success-tree
@@ -0,0 +1,27 @@
+./0e/ad45fc727edcf5cadca25ef922284f32bb6fc1
+./15/926d8d6d17d1cbdf7f03c457e8ff983270f363
+./18/bd3fc20b0565f94bce0a3e94b6a83b26b88627
+./1d/fd336d2290794b0b1f80d98af33f725da6f42d
+./2b/621c1a3aac23b8258885a9b4658d9ac993742f
+./2c/1e59ee54facb7d72c0061d06b9fe3889f357a9
+./2d/ad8b277db3a95919bd904133d7e7cc3e323cb9
+./3a/b660ad62dd7c8c8bd637aa9bc1c2843a8439fe
+./3d/650a1c41a4529863818fd613b95e83668bbfc1
+./41/97ce3c6d943759e1088a0298b64571b4bc725a
+./50/1b297447a8255d3533c6858bb692575cdefaa0
+./5d/e2eda652f29103c0d160f8c05d7e83b653a157
+./66/74d310d179400358d581f9725cbd4a2c32e3bf
+./68/b95733c796b12571fb1f656062a15a78e7dcf4
+./83/d9602eccfc733a550812ce492d4caa0af625c8
+./84/26f672fc65239135b1f1580bb79ecb16fd05f0
+./84/81dbefa2fb9398a673fe1f48dc480c1f558890
+./85/48234cfc7b4f0c9475d24d4c386783533a8034
+./88/58983d81b0eef76eb55d21a0d96b7b16846eca
+./a2/9ebd0e0fcbcd2a0842dd44cc7c22a90a310a3a
+./af/4f6405296dec699321ca59d48583ffa0323b0e
+./b2/025146d0718d953036352f8435cfa392b1d799
+./bb/a287531b3a845faa032a8fef3e6d70d185c89b
+./bd/91890c62d85ec16aadd3fb991b3ad7a365adde
+./cb/572206d9dac4ba52878e7e1a4a7028d85707ab
+./e2/34c232ce0b8acef3f43fa34c036e68522b5612
+./e8/00b9c207e17f9b11e321cc1fba5dfe08af4222
\ No newline at end of file
diff --git a/tests/tools/src/lib.rs b/tests/tools/src/lib.rs
index 882231c6f48..19f71bb6584 100644
--- a/tests/tools/src/lib.rs
+++ b/tests/tools/src/lib.rs
@@ -403,7 +403,7 @@ pub fn copy_recursively_into_existing_dir(src_dir: impl AsRef<Path>, dst_dir: im
             ..Default::default()
         },
     )
-    .map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err))?;
+    .map_err(std::io::Error::other)?;
     Ok(())
 }
 
@@ -474,8 +474,9 @@ fn scripted_fixture_read_only_with_args_inner(
                 let mut crc_digest = crc_value.digest();
                 crc_digest.update(&std::fs::read(&script_path).unwrap_or_else(|err| {
                     panic!(
-                        "file {script_path:?} in CWD {:?} could not be read: {err}",
-                        env::current_dir().expect("valid cwd"),
+                        "file {script_path} in CWD '{cwd}' could not be read: {err}",
+                        cwd = env::current_dir().expect("valid cwd").display(),
+                        script_path = script_path.display(),
                     )
                 }));
                 for arg in &args {
@@ -537,7 +538,10 @@ fn scripted_fixture_read_only_with_args_inner(
     let failure_marker = script_result_directory.join("_invalid_state_due_to_script_failure_");
     if force_run || !script_result_directory.is_dir() || failure_marker.is_file() {
         if failure_marker.is_file() {
-            std::fs::remove_dir_all(&script_result_directory).map_err(|err| format!("Failed to remove '{script_result_directory:?}', please try to do that by hand. Original error: {err}"))?;
+            std::fs::remove_dir_all(&script_result_directory).map_err(|err| {
+                format!("Failed to remove '{script_result_directory}', please try to do that by hand. Original error: {err}",
+                        script_result_directory = script_result_directory.display())
+            })?;
         }
         std::fs::create_dir_all(&script_result_directory)?;
         let script_identity_for_archive = match args_in_hash {
@@ -560,7 +564,11 @@ fn scripted_fixture_read_only_with_args_inner(
             Err(err) => {
                 if err.kind() != std::io::ErrorKind::NotFound {
                     eprintln!("failed to extract '{}': {}", archive_file_path.display(), err);
-                    std::fs::remove_dir_all(&script_result_directory).map_err(|err| format!("Failed to remove '{script_result_directory:?}', please try to do that by hand. Original error: {err}"))?;
+                    std::fs::remove_dir_all(&script_result_directory)
+                        .map_err(|err| {
+                            format!("Failed to remove '{script_result_directory}', please try to do that by hand. Original error: {err}",
+                                    script_result_directory = script_result_directory.display())
+                        })?;
                     std::fs::create_dir_all(&script_result_directory)?;
                 } else if !is_excluded(&archive_file_path) {
                     eprintln!(
@@ -574,11 +582,11 @@ fn scripted_fixture_read_only_with_args_inner(
                 let output = match configure_command(&mut cmd, &args, &script_result_directory).output() {
                     Ok(out) => out,
                     Err(err)
-                        if err.kind() == std::io::ErrorKind::PermissionDenied || err.raw_os_error() == Some(193) /* windows */ =>
-                    {
-                        cmd = std::process::Command::new(bash_program());
-                        configure_command(cmd.arg(script_absolute_path), &args, &script_result_directory).output()?
-                    }
+                    if err.kind() == std::io::ErrorKind::PermissionDenied || err.raw_os_error() == Some(193) /* windows */ =>
+                        {
+                            cmd = std::process::Command::new(bash_program());
+                            configure_command(cmd.arg(script_absolute_path), &args, &script_result_directory).output()?
+                        }
                     Err(err) => return Err(err.into()),
                 };
                 if !output.status.success() {
@@ -830,13 +838,10 @@ fn extract_archive(
         #[cfg_attr(feature = "xz", allow(unused_mut))]
         let mut input_archive = std::fs::File::open(archive)?;
         if env::var_os("GIX_TEST_IGNORE_ARCHIVES").is_some() {
-            return Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!(
-                    "Ignoring archive at '{}' as GIX_TEST_IGNORE_ARCHIVES is set.",
-                    archive.display()
-                ),
-            ));
+            return Err(std::io::Error::other(format!(
+                "Ignoring archive at '{}' as GIX_TEST_IGNORE_ARCHIVES is set.",
+                archive.display()
+            )));
         }
         #[cfg(feature = "xz")]
         {
@@ -868,17 +873,12 @@ fn extract_archive(
                 None
             }
         })
-        .ok_or_else(|| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                "BUG: Could not find meta directory in our own archive",
-            )
-        })
+        .ok_or_else(|| std::io::Error::other("BUG: Could not find meta directory in our own archive"))
         .map_err(|err| {
-            std::io::Error::new(
-                std::io::ErrorKind::Other,
-                format!("Could not extract archive at '{archive:?}': {err}"),
-            )
+            std::io::Error::other(format!(
+                "Could not extract archive at '{archive}': {err}",
+                archive = archive.display()
+            ))
         })?;
     if archive_identity != required_script_identity {
         eprintln!(
diff --git a/tests/tools/src/main.rs b/tests/tools/src/main.rs
index 66a485dd360..813fcce3ca7 100644
--- a/tests/tools/src/main.rs
+++ b/tests/tools/src/main.rs
@@ -5,7 +5,7 @@ fn bash_program() -> io::Result<()> {
     if !std::io::stdout().is_terminal() {
         eprintln!("warning: `bash-program` subcommand not meant for scripting, format may change");
     }
-    println!("{:?}", gix_testtools::bash_program());
+    println!("{}", gix_testtools::bash_program().display());
     Ok(())
 }
 
diff --git a/tests/tools/tests/umask.rs b/tests/tools/tests/umask.rs
index 5463b57ad49..11f546b219e 100644
--- a/tests/tools/tests/umask.rs
+++ b/tests/tools/tests/umask.rs
@@ -5,8 +5,10 @@
     ignore = "The test itself uses /proc"
 )]
 fn umask() {
-    use std::fs::File;
-    use std::io::{BufRead, BufReader};
+    use std::{
+        fs::File,
+        io::{BufRead, BufReader},
+    };
 
     use bstr::ByteSlice;
     // Check against the umask obtained via a less portable but also completely safe method.